initial import of NetBSD tree

1 files changed, 1523 insertions, 0 deletions

diff --git a/bin/csh/func.c b/bin/csh/func.c
new file mode 100644
index 00000000000..ba70e9753b2
--- /dev/null
+++ b/bin/csh/func.c
@@ -0,0 +1,1523 @@
+/*	$NetBSD: func.c,v 1.10 1995/03/21 18:35:42 mycroft Exp $	*/
+
+/*-
+ * Copyright (c) 1980, 1991, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef lint
+#if 0
+static char sccsid[] = "@(#)func.c	8.1 (Berkeley) 5/31/93";
+#else
+static char rcsid[] = "$NetBSD: func.c,v 1.10 1995/03/21 18:35:42 mycroft Exp $";
+#endif
+#endif /* not lint */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <locale.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#if __STDC__
+# include <stdarg.h>
+#else
+# include <varargs.h>
+#endif
+
+#include "csh.h"
+#include "extern.h"
+#include "pathnames.h"
+
+extern char **environ;
+
+static int zlast = -1;
+static void	islogin __P((void));
+static void	reexecute __P((struct command *));
+static void	preread __P((void));
+static void	doagain __P((void));
+static void	search __P((int, int, Char *));
+static int	getword __P((Char *));
+static int	keyword __P((Char *));
+static void	toend __P((void));
+static void	xecho __P((int, Char **));
+static void	Unsetenv __P((Char *));
+
+struct biltins *
+isbfunc(t)
+    struct command *t;
+{
+    register Char *cp = t->t_dcom[0];
+    register struct biltins *bp, *bp1, *bp2;
+    static struct biltins label = {"", dozip, 0, 0};
+    static struct biltins foregnd = {"%job", dofg1, 0, 0};
+    static struct biltins backgnd = {"%job &", dobg1, 0, 0};
+
+    if (lastchr(cp) == ':') {
+	label.bname = short2str(cp);
+	return (&label);
+    }
+    if (*cp == '%') {
+	if (t->t_dflg & F_AMPERSAND) {
+	    t->t_dflg &= ~F_AMPERSAND;
+	    backgnd.bname = short2str(cp);
+	    return (&backgnd);
+	}
+	foregnd.bname = short2str(cp);
+	return (&foregnd);
+    }
+    /*
+     * Binary search Bp1 is the beginning of the current search range. Bp2 is
+     * one past the end.
+     */
+    for (bp1 = bfunc, bp2 = bfunc + nbfunc; bp1 < bp2;) {
+	register i;
+
+	bp = bp1 + ((bp2 - bp1) >> 1);
+	if ((i = *cp - *bp->bname) == 0 &&
+	    (i = Strcmp(cp, str2short(bp->bname))) == 0)
+	    return bp;
+	if (i < 0)
+	    bp2 = bp;
+	else
+	    bp1 = bp + 1;
+    }
+    return (0);
+}
+
+void
+func(t, bp)
+    register struct command *t;
+    register struct biltins *bp;
+{
+    int     i;
+
+    xechoit(t->t_dcom);
+    setname(bp->bname);
+    i = blklen(t->t_dcom) - 1;
+    if (i < bp->minargs)
+	stderror(ERR_NAME | ERR_TOOFEW);
+    if (i > bp->maxargs)
+	stderror(ERR_NAME | ERR_TOOMANY);
+    (*bp->bfunct) (t->t_dcom, t);
+}
+
+void
+/*ARGSUSED*/
+doonintr(v, t)
+    Char **v;
+    struct command *t;
+{
+    register Char *cp;
+    register Char *vv = v[1];
+    sigset_t sigset;
+
+    if (parintr == SIG_IGN)
+	return;
+    if (setintr && intty)
+	stderror(ERR_NAME | ERR_TERMINAL);
+    cp = gointr;
+    gointr = 0;
+    xfree((ptr_t) cp);
+    if (vv == 0) {
+	if (setintr) {
+	    sigemptyset(&sigset);
+	    sigaddset(&sigset, SIGINT);
+	    sigprocmask(SIG_BLOCK, &sigset, NULL);
+	} else
+	    (void) signal(SIGINT, SIG_DFL);
+	gointr = 0;
+    }
+    else if (eq((vv = strip(vv)), STRminus)) {
+	(void) signal(SIGINT, SIG_IGN);
+	gointr = Strsave(STRminus);
+    }
+    else {
+	gointr = Strsave(vv);
+	(void) signal(SIGINT, pintr);
+    }
+}
+
+void
+/*ARGSUSED*/
+donohup(v, t)
+    Char **v;
+    struct command *t;
+{
+    if (intty)
+	stderror(ERR_NAME | ERR_TERMINAL);
+    if (setintr == 0) {
+	(void) signal(SIGHUP, SIG_IGN);
+    }
+}
+
+void
+/*ARGSUSED*/
+dozip(v, t)
+    Char **v;
+    struct command *t;
+{
+    ;
+}
+
+void
+prvars()
+{
+    plist(&shvhed);
+}
+
+void
+/*ARGSUSED*/
+doalias(v, t)
+    Char **v;
+    struct command *t;
+{
+    register struct varent *vp;
+    register Char *p;
+
+    v++;
+    p = *v++;
+    if (p == 0)
+	plist(&aliases);
+    else if (*v == 0) {
+	vp = adrof1(strip(p), &aliases);
+	if (vp) {
+	    blkpr(cshout, vp->vec);
+	    fputc('\n', cshout);
+	}
+    }
+    else {
+	if (eq(p, STRalias) || eq(p, STRunalias)) {
+	    setname(vis_str(p));
+	    stderror(ERR_NAME | ERR_DANGER);
+	}
+	set1(strip(p), saveblk(v), &aliases);
+    }
+}
+
+void
+/*ARGSUSED*/
+unalias(v, t)
+    Char **v;
+    struct command *t;
+{
+    unset1(v, &aliases);
+}
+
+void
+/*ARGSUSED*/
+dologout(v, t)
+    Char **v;
+    struct command *t;
+{
+    islogin();
+    goodbye();
+}
+
+void
+/*ARGSUSED*/
+dologin(v, t)
+    Char **v;
+    struct command *t;
+{
+    islogin();
+    rechist();
+    (void) signal(SIGTERM, parterm);
+    (void) execl(_PATH_LOGIN, "login", short2str(v[1]), NULL);
+    untty();
+    xexit(1);
+}
+
+static void
+islogin()
+{
+    if (chkstop == 0 && setintr)
+	panystop(0);
+    if (loginsh)
+	return;
+    stderror(ERR_NOTLOGIN);
+}
+
+void
+doif(v, kp)
+    Char  **v;
+    struct command *kp;
+{
+    register int i;
+    register Char **vv;
+
+    v++;
+    i = expr(&v);
+    vv = v;
+    if (*vv == NULL)
+	stderror(ERR_NAME | ERR_EMPTYIF);
+    if (eq(*vv, STRthen)) {
+	if (*++vv)
+	    stderror(ERR_NAME | ERR_IMPRTHEN);
+	setname(vis_str(STRthen));
+	/*
+	 * If expression was zero, then scan to else, otherwise just fall into
+	 * following code.
+	 */
+	if (!i)
+	    search(T_IF, 0, NULL);
+	return;
+    }
+    /*
+     * Simple command attached to this if. Left shift the node in this tree,
+     * munging it so we can reexecute it.
+     */
+    if (i) {
+	lshift(kp->t_dcom, vv - kp->t_dcom);
+	reexecute(kp);
+	donefds();
+    }
+}
+
+/*
+ * Reexecute a command, being careful not
+ * to redo i/o redirection, which is already set up.
+ */
+static void
+reexecute(kp)
+    register struct command *kp;
+{
+    kp->t_dflg &= F_SAVE;
+    kp->t_dflg |= F_REPEAT;
+    /*
+     * If tty is still ours to arbitrate, arbitrate it; otherwise dont even set
+     * pgrp's as the jobs would then have no way to get the tty (we can't give
+     * it to them, and our parent wouldn't know their pgrp, etc.
+     */
+    execute(kp, (tpgrp > 0 ? tpgrp : -1), NULL, NULL);
+}
+
+void
+/*ARGSUSED*/
+doelse(v, t)
+    Char **v;
+    struct command *t;
+{
+    search(T_ELSE, 0, NULL);
+}
+
+void
+/*ARGSUSED*/
+dogoto(v, t)
+    Char **v;
+    struct command *t;
+{
+    Char   *lp;
+
+    gotolab(lp = globone(v[1], G_ERROR));
+    xfree((ptr_t) lp);
+}
+
+void
+gotolab(lab)
+    Char *lab;
+{
+    register struct whyle *wp;
+    /*
+     * While we still can, locate any unknown ends of existing loops. This
+     * obscure code is the WORST result of the fact that we don't really parse.
+     */
+    zlast = T_GOTO;
+    for (wp = whyles; wp; wp = wp->w_next)
+	if (wp->w_end.type == F_SEEK && wp->w_end.f_seek == 0) {
+	    search(T_BREAK, 0, NULL);
+	    btell(&wp->w_end);
+	}
+	else
+	    bseek(&wp->w_end);
+    search(T_GOTO, 0, lab);
+    /*
+     * Eliminate loops which were exited.
+     */
+    wfree();
+}
+
+void
+/*ARGSUSED*/
+doswitch(v, t)
+    Char **v;
+    struct command *t;
+{
+    register Char *cp, *lp;
+
+    v++;
+    if (!*v || *(*v++) != '(')
+	stderror(ERR_SYNTAX);
+    cp = **v == ')' ? STRNULL : *v++;
+    if (*(*v++) != ')')
+	v--;
+    if (*v)
+	stderror(ERR_SYNTAX);
+    search(T_SWITCH, 0, lp = globone(cp, G_ERROR));
+    xfree((ptr_t) lp);
+}
+
+void
+/*ARGSUSED*/
+dobreak(v, t)
+    Char **v;
+    struct command *t;
+{
+    if (whyles)
+	toend();
+    else
+	stderror(ERR_NAME | ERR_NOTWHILE);
+}
+
+void
+/*ARGSUSED*/
+doexit(v, t)
+    Char **v;
+    struct command *t;
+{
+    if (chkstop == 0 && (intty || intact) && evalvec == 0)
+	panystop(0);
+    /*
+     * Don't DEMAND parentheses here either.
+     */
+    v++;
+    if (*v) {
+	set(STRstatus, putn(expr(&v)));
+	if (*v)
+	    stderror(ERR_NAME | ERR_EXPRESSION);
+    }
+    btoeof();
+    if (intty)
+	(void) close(SHIN);
+}
+
+void
+/*ARGSUSED*/
+doforeach(v, t)
+    Char **v;
+    struct command *t;
+{
+    register Char *cp, *sp;
+    register struct whyle *nwp;
+
+    v++;
+    sp = cp = strip(*v);
+    if (!letter(*sp))
+	stderror(ERR_NAME | ERR_VARBEGIN);
+    while (*cp && alnum(*cp))
+	cp++;
+    if (*cp)
+	stderror(ERR_NAME | ERR_VARALNUM);
+    if ((cp - sp) > MAXVARLEN)
+	stderror(ERR_NAME | ERR_VARTOOLONG);
+    cp = *v++;
+    if (v[0][0] != '(' || v[blklen(v) - 1][0] != ')')
+	stderror(ERR_NAME | ERR_NOPAREN);
+    v++;
+    gflag = 0, tglob(v);
+    v = globall(v);
+    if (v == 0)
+	stderror(ERR_NAME | ERR_NOMATCH);
+    nwp = (struct whyle *) xcalloc(1, sizeof *nwp);
+    nwp->w_fe = nwp->w_fe0 = v;
+    gargv = 0;
+    btell(&nwp->w_start);
+    nwp->w_fename = Strsave(cp);
+    nwp->w_next = whyles;
+    nwp->w_end.type = F_SEEK;
+    whyles = nwp;
+    /*
+     * Pre-read the loop so as to be more comprehensible to a terminal user.
+     */
+    zlast = T_FOREACH;
+    if (intty)
+	preread();
+    doagain();
+}
+
+void
+/*ARGSUSED*/
+dowhile(v, t)
+    Char **v;
+    struct command *t;
+{
+    register int status;
+    register bool again = whyles != 0 && SEEKEQ(&whyles->w_start, &lineloc) &&
+    whyles->w_fename == 0;
+
+    v++;
+    /*
+     * Implement prereading here also, taking care not to evaluate the
+     * expression before the loop has been read up from a terminal.
+     */
+    if (intty && !again)
+	status = !exp0(&v, 1);
+    else
+	status = !expr(&v);
+    if (*v)
+	stderror(ERR_NAME | ERR_EXPRESSION);
+    if (!again) {
+	register struct whyle *nwp =
+	(struct whyle *) xcalloc(1, sizeof(*nwp));
+
+	nwp->w_start = lineloc;
+	nwp->w_end.type = F_SEEK;
+	nwp->w_end.f_seek = 0;
+	nwp->w_next = whyles;
+	whyles = nwp;
+	zlast = T_WHILE;
+	if (intty) {
+	    /*
+	     * The tty preread
+	     */
+	    preread();
+	    doagain();
+	    return;
+	}
+    }
+    if (status)
+	/* We ain't gonna loop no more, no more! */
+	toend();
+}
+
+static void
+preread()
+{
+    sigset_t sigset;
+
+    whyles->w_end.type = I_SEEK;
+    if (setintr) {
+	sigemptyset(&sigset);
+	sigaddset(&sigset, SIGINT);
+	sigprocmask(SIG_UNBLOCK, &sigset, NULL);
+    }
+
+    search(T_BREAK, 0, NULL);		/* read the expression in */
+    if (setintr)
+	sigprocmask(SIG_BLOCK, &sigset, NULL);
+    btell(&whyles->w_end);
+}
+
+void
+/*ARGSUSED*/
+doend(v, t)
+    Char **v;
+    struct command *t;
+{
+    if (!whyles)
+	stderror(ERR_NAME | ERR_NOTWHILE);
+    btell(&whyles->w_end);
+    doagain();
+}
+
+void
+/*ARGSUSED*/
+docontin(v, t)
+    Char **v;
+    struct command *t;
+{
+    if (!whyles)
+	stderror(ERR_NAME | ERR_NOTWHILE);
+    doagain();
+}
+
+static void
+doagain()
+{
+    /* Repeating a while is simple */
+    if (whyles->w_fename == 0) {
+	bseek(&whyles->w_start);
+	return;
+    }
+    /*
+     * The foreach variable list actually has a spurious word ")" at the end of
+     * the w_fe list.  Thus we are at the of the list if one word beyond this
+     * is 0.
+     */
+    if (!whyles->w_fe[1]) {
+	dobreak(NULL, NULL);
+	return;
+    }
+    set(whyles->w_fename, Strsave(*whyles->w_fe++));
+    bseek(&whyles->w_start);
+}
+
+void
+dorepeat(v, kp)
+    Char  **v;
+    struct command *kp;
+{
+    register int i;
+    sigset_t sigset;
+
+    i = getn(v[1]);
+    if (setintr) {
+	sigemptyset(&sigset);
+	sigaddset(&sigset, SIGINT);
+	sigprocmask(SIG_BLOCK, &sigset, NULL);
+    }
+    lshift(v, 2);
+    while (i > 0) {
+	if (setintr)
+	    sigprocmask(SIG_UNBLOCK, &sigset, NULL);
+	reexecute(kp);
+	--i;
+    }
+    donefds();
+    if (setintr)
+	sigprocmask(SIG_UNBLOCK, &sigset, NULL);
+}
+
+void
+/*ARGSUSED*/
+doswbrk(v, t)
+    Char **v;
+    struct command *t;
+{
+    search(T_BRKSW, 0, NULL);
+}
+
+int
+srchx(cp)
+    register Char *cp;
+{
+    register struct srch *sp, *sp1, *sp2;
+    register i;
+
+    /*
+     * Binary search Sp1 is the beginning of the current search range. Sp2 is
+     * one past the end.
+     */
+    for (sp1 = srchn, sp2 = srchn + nsrchn; sp1 < sp2;) {
+	sp = sp1 + ((sp2 - sp1) >> 1);
+	if ((i = *cp - *sp->s_name) == 0 &&
+	    (i = Strcmp(cp, str2short(sp->s_name))) == 0)
+	    return sp->s_value;
+	if (i < 0)
+	    sp2 = sp;
+	else
+	    sp1 = sp + 1;
+    }
+    return (-1);
+}
+
+static Char Stype;
+static Char *Sgoal;
+
+/*VARARGS2*/
+static void
+search(type, level, goal)
+    int     type;
+    register int level;
+    Char   *goal;
+{
+    Char    wordbuf[BUFSIZ];
+    register Char *aword = wordbuf;
+    register Char *cp;
+
+    Stype = type;
+    Sgoal = goal;
+    if (type == T_GOTO) {
+	struct Ain a;
+	a.type = F_SEEK;
+	a.f_seek = 0;
+	bseek(&a);
+    }
+    do {
+	if (intty && fseekp == feobp && aret == F_SEEK)
+	    (void) fprintf(cshout, "? "), (void) fflush(cshout);
+	aword[0] = 0;
+	(void) getword(aword);
+	switch (srchx(aword)) {
+
+	case T_ELSE:
+	    if (level == 0 && type == T_IF)
+		return;
+	    break;
+
+	case T_IF:
+	    while (getword(aword))
+		continue;
+	    if ((type == T_IF || type == T_ELSE) &&
+		eq(aword, STRthen))
+		level++;
+	    break;
+
+	case T_ENDIF:
+	    if (type == T_IF || type == T_ELSE)
+		level--;
+	    break;
+
+	case T_FOREACH:
+	case T_WHILE:
+	    if (type == T_BREAK)
+		level++;
+	    break;
+
+	case T_END:
+	    if (type == T_BREAK)
+		level--;
+	    break;
+
+	case T_SWITCH:
+	    if (type == T_SWITCH || type == T_BRKSW)
+		level++;
+	    break;
+
+	case T_ENDSW:
+	    if (type == T_SWITCH || type == T_BRKSW)
+		level--;
+	    break;
+
+	case T_LABEL:
+	    if (type == T_GOTO && getword(aword) && eq(aword, goal))
+		level = -1;
+	    break;
+
+	default:
+	    if (type != T_GOTO && (type != T_SWITCH || level != 0))
+		break;
+	    if (lastchr(aword) != ':')
+		break;
+	    aword[Strlen(aword) - 1] = 0;
+	    if ((type == T_GOTO && eq(aword, goal)) ||
+		(type == T_SWITCH && eq(aword, STRdefault)))
+		level = -1;
+	    break;
+
+	case T_CASE:
+	    if (type != T_SWITCH || level != 0)
+		break;
+	    (void) getword(aword);
+	    if (lastchr(aword) == ':')
+		aword[Strlen(aword) - 1] = 0;
+	    cp = strip(Dfix1(aword));
+	    if (Gmatch(goal, cp))
+		level = -1;
+	    xfree((ptr_t) cp);
+	    break;
+
+	case T_DEFAULT:
+	    if (type == T_SWITCH && level == 0)
+		level = -1;
+	    break;
+	}
+	(void) getword(NULL);
+    } while (level >= 0);
+}
+
+static int
+getword(wp)
+    register Char *wp;
+{
+    register int found = 0;
+    register int c, d;
+    int     kwd = 0;
+    Char   *owp = wp;
+
+    c = readc(1);
+    d = 0;
+    do {
+	while (c == ' ' || c == '\t')
+	    c = readc(1);
+	if (c == '#')
+	    do
+		c = readc(1);
+	    while (c >= 0 && c != '\n');
+	if (c < 0)
+	    goto past;
+	if (c == '\n') {
+	    if (wp)
+		break;
+	    return (0);
+	}
+	unreadc(c);
+	found = 1;
+	do {
+	    c = readc(1);
+	    if (c == '\\' && (c = readc(1)) == '\n')
+		c = ' ';
+	    if (c == '\'' || c == '"')
+		if (d == 0)
+		    d = c;
+		else if (d == c)
+		    d = 0;
+	    if (c < 0)
+		goto past;
+	    if (wp) {
+		*wp++ = c;
+		*wp = 0;	/* end the string b4 test */
+	    }
+	} while ((d || (!(kwd = keyword(owp)) && c != ' '
+		  && c != '\t')) && c != '\n');
+    } while (wp == 0);
+
+    /*
+     * if we have read a keyword ( "if", "switch" or "while" ) then we do not
+     * need to unreadc the look-ahead char
+     */
+    if (!kwd) {
+	unreadc(c);
+	if (found)
+	    *--wp = 0;
+    }
+
+    return (found);
+
+past:
+    switch (Stype) {
+
+    case T_IF:
+	stderror(ERR_NAME | ERR_NOTFOUND, "then/endif");
+
+    case T_ELSE:
+	stderror(ERR_NAME | ERR_NOTFOUND, "endif");
+
+    case T_BRKSW:
+    case T_SWITCH:
+	stderror(ERR_NAME | ERR_NOTFOUND, "endsw");
+
+    case T_BREAK:
+	stderror(ERR_NAME | ERR_NOTFOUND, "end");
+
+    case T_GOTO:
+	setname(vis_str(Sgoal));
+	stderror(ERR_NAME | ERR_NOTFOUND, "label");
+    }
+    /* NOTREACHED */
+    return (0);
+}
+
+/*
+ * keyword(wp) determines if wp is one of the built-n functions if,
+ * switch or while. It seems that when an if statement looks like
+ * "if(" then getword above sucks in the '(' and so the search routine
+ * never finds what it is scanning for. Rather than rewrite doword, I hack
+ * in a test to see if the string forms a keyword. Then doword stops
+ * and returns the word "if" -strike
+ */
+
+static int
+keyword(wp)
+    Char   *wp;
+{
+    static Char STRif[] = {'i', 'f', '\0'};
+    static Char STRwhile[] = {'w', 'h', 'i', 'l', 'e', '\0'};
+    static Char STRswitch[] = {'s', 'w', 'i', 't', 'c', 'h', '\0'};
+
+    if (!wp)
+	return (0);
+
+    if ((Strcmp(wp, STRif) == 0) || (Strcmp(wp, STRwhile) == 0)
+	|| (Strcmp(wp, STRswitch) == 0))
+	return (1);
+
+    return (0);
+}
+
+static void
+toend()
+{
+    if (whyles->w_end.type == F_SEEK && whyles->w_end.f_seek == 0) {
+	search(T_BREAK, 0, NULL);
+	btell(&whyles->w_end);
+	whyles->w_end.f_seek--;
+    }
+    else
+	bseek(&whyles->w_end);
+    wfree();
+}
+
+void
+wfree()
+{
+    struct Ain    o;
+    struct whyle *nwp;
+
+    btell(&o);
+
+    for (; whyles; whyles = nwp) {
+	register struct whyle *wp = whyles;
+	nwp = wp->w_next;
+
+	/*
+	 * We free loops that have different seek types.
+	 */
+	if (wp->w_end.type != I_SEEK && wp->w_start.type == wp->w_end.type &&
+	    wp->w_start.type == o.type) {
+	    if (wp->w_end.type == F_SEEK) {
+		if (o.f_seek >= wp->w_start.f_seek && 
+		    (wp->w_end.f_seek == 0 || o.f_seek < wp->w_end.f_seek))
+		    break;
+	    }
+	    else {
+		if (o.a_seek >= wp->w_start.a_seek && 
+		    (wp->w_end.a_seek == 0 || o.a_seek < wp->w_end.a_seek))
+		    break;
+	    }
+	}
+
+	if (wp->w_fe0)
+	    blkfree(wp->w_fe0);
+	if (wp->w_fename)
+	    xfree((ptr_t) wp->w_fename);
+	xfree((ptr_t) wp);
+    }
+}
+
+void
+/*ARGSUSED*/
+doecho(v, t)
+    Char **v;
+    struct command *t;
+{
+    xecho(' ', v);
+}
+
+void
+/*ARGSUSED*/
+doglob(v, t)
+    Char **v;
+    struct command *t;
+{
+    xecho(0, v);
+    (void) fflush(cshout);
+}
+
+static void
+xecho(sep, v)
+    int    sep;
+    register Char **v;
+{
+    register Char *cp;
+    int     nonl = 0;
+    sigset_t sigset;
+
+    if (setintr) {
+	sigemptyset(&sigset);
+	sigaddset(&sigset, SIGINT);
+	sigprocmask(SIG_UNBLOCK, &sigset, NULL);
+    }
+    v++;
+    if (*v == 0)
+	return;
+    gflag = 0, tglob(v);
+    if (gflag) {
+	v = globall(v);
+	if (v == 0)
+	    stderror(ERR_NAME | ERR_NOMATCH);
+    }
+    else {
+	v = gargv = saveblk(v);
+	trim(v);
+    }
+    if (sep == ' ' && *v && eq(*v, STRmn))
+	nonl++, v++;
+    while ((cp = *v++) != NULL) {
+	register int c;
+
+	while ((c = *cp++) != '\0')
+	    (void) vis_fputc(c | QUOTE, cshout);
+
+	if (*v)
+	    (void) vis_fputc(sep | QUOTE, cshout);
+    }
+    if (sep && nonl == 0)
+	(void) fputc('\n', cshout);
+    else
+	(void) fflush(cshout);
+    if (setintr)
+	sigprocmask(SIG_BLOCK, &sigset, NULL);
+    if (gargv)
+	blkfree(gargv), gargv = 0;
+}
+
+void
+/*ARGSUSED*/
+dosetenv(v, t)
+    Char **v;
+    struct command *t;
+{
+    Char   *vp, *lp;
+    sigset_t sigset;
+
+    v++;
+    if ((vp = *v++) == 0) {
+	register Char **ep;
+
+	if (setintr) {
+	    sigemptyset(&sigset);
+	    sigaddset(&sigset, SIGINT);
+	    sigprocmask(SIG_UNBLOCK, &sigset, NULL);
+	}
+	for (ep = STR_environ; *ep; ep++)
+	    (void) fprintf(cshout, "%s\n", vis_str(*ep));
+	return;
+    }
+    if ((lp = *v++) == 0)
+	lp = STRNULL;
+    Setenv(vp, lp = globone(lp, G_APPEND));
+    if (eq(vp, STRPATH)) {
+	importpath(lp);
+	dohash(NULL, NULL);
+    }
+    else if (eq(vp, STRLANG) || eq(vp, STRLC_CTYPE)) {
+#ifdef NLS
+	int     k;
+
+	(void) setlocale(LC_ALL, "");
+	for (k = 0200; k <= 0377 && !Isprint(k); k++)
+		continue;
+	AsciiOnly = k > 0377;
+#else
+	AsciiOnly = 0;
+#endif				/* NLS */
+    }
+    xfree((ptr_t) lp);
+}
+
+void
+/*ARGSUSED*/
+dounsetenv(v, t)
+    Char **v;
+    struct command *t;
+{
+    Char  **ep, *p, *n;
+    int     i, maxi;
+    static Char *name = NULL;
+
+    if (name)
+	xfree((ptr_t) name);
+    /*
+     * Find the longest environment variable
+     */
+    for (maxi = 0, ep = STR_environ; *ep; ep++) {
+	for (i = 0, p = *ep; *p && *p != '='; p++, i++)
+	    continue;
+	if (i > maxi)
+	    maxi = i;
+    }
+
+    name = (Char *) xmalloc((size_t) (maxi + 1) * sizeof(Char));
+
+    while (++v && *v)
+	for (maxi = 1; maxi;)
+	    for (maxi = 0, ep = STR_environ; *ep; ep++) {
+		for (n = name, p = *ep; *p && *p != '='; *n++ = *p++)
+		    continue;
+		*n = '\0';
+		if (!Gmatch(name, *v))
+		    continue;
+		maxi = 1;
+		if (eq(name, STRLANG) || eq(name, STRLC_CTYPE)) {
+#ifdef NLS
+		    int     k;
+
+		    (void) setlocale(LC_ALL, "");
+		    for (k = 0200; k <= 0377 && !Isprint(k); k++)
+			continue;
+		    AsciiOnly = k > 0377;
+#else
+		    AsciiOnly = getenv("LANG") == NULL &&
+			getenv("LC_CTYPE") == NULL;
+#endif				/* NLS */
+		}
+		/*
+		 * Delete name, and start again cause the environment changes
+		 */
+		Unsetenv(name);
+		break;
+	    }
+    xfree((ptr_t) name);
+    name = NULL;
+}
+
+void
+Setenv(name, val)
+    Char   *name, *val;
+{
+    register Char **ep = STR_environ;
+    register Char *cp, *dp;
+    Char   *blk[2];
+    Char  **oep = ep;
+
+
+    for (; *ep; ep++) {
+	for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
+	    continue;
+	if (*cp != 0 || *dp != '=')
+	    continue;
+	cp = Strspl(STRequal, val);
+	xfree((ptr_t) * ep);
+	*ep = strip(Strspl(name, cp));
+	xfree((ptr_t) cp);
+	blkfree((Char **) environ);
+	environ = short2blk(STR_environ);
+	return;
+    }
+    cp = Strspl(name, STRequal);
+    blk[0] = strip(Strspl(cp, val));
+    xfree((ptr_t) cp);
+    blk[1] = 0;
+    STR_environ = blkspl(STR_environ, blk);
+    blkfree((Char **) environ);
+    environ = short2blk(STR_environ);
+    xfree((ptr_t) oep);
+}
+
+static void
+Unsetenv(name)
+    Char   *name;
+{
+    register Char **ep = STR_environ;
+    register Char *cp, *dp;
+    Char  **oep = ep;
+
+    for (; *ep; ep++) {
+	for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
+	    continue;
+	if (*cp != 0 || *dp != '=')
+	    continue;
+	cp = *ep;
+	*ep = 0;
+	STR_environ = blkspl(STR_environ, ep + 1);
+	environ = short2blk(STR_environ);
+	*ep = cp;
+	xfree((ptr_t) cp);
+	xfree((ptr_t) oep);
+	return;
+    }
+}
+
+void
+/*ARGSUSED*/
+doumask(v, t)
+    Char **v;
+    struct command *t;
+{
+    register Char *cp = v[1];
+    register int i;
+
+    if (cp == 0) {
+	i = umask(0);
+	(void) umask(i);
+	(void) fprintf(cshout, "%o\n", i);
+	return;
+    }
+    i = 0;
+    while (Isdigit(*cp) && *cp != '8' && *cp != '9')
+	i = i * 8 + *cp++ - '0';
+    if (*cp || i < 0 || i > 0777)
+	stderror(ERR_NAME | ERR_MASK);
+    (void) umask(i);
+}
+
+typedef quad_t RLIM_TYPE;
+
+static struct limits {
+    int     limconst;
+    char   *limname;
+    int     limdiv;
+    char   *limscale;
+}       limits[] = {
+    { RLIMIT_CPU,	"cputime",	1,	"seconds" },
+    { RLIMIT_FSIZE,	"filesize",	1024,	"kbytes" },
+    { RLIMIT_DATA,	"datasize",	1024,	"kbytes" },
+    { RLIMIT_STACK,	"stacksize",	1024,	"kbytes" },
+    { RLIMIT_CORE,	"coredumpsize", 1024,	"kbytes" },
+    { RLIMIT_RSS,	"memoryuse",	1024,	"kbytes" },
+    { RLIMIT_MEMLOCK,	"memorylocked",	1024,	"kbytes" },
+    { RLIMIT_NPROC,	"maxproc",	1,	"" },
+    { RLIMIT_NOFILE,	"openfiles",	1,	"" },
+    { -1,		NULL,		0,	NULL }
+};
+
+static struct limits *findlim __P((Char *));
+static RLIM_TYPE getval __P((struct limits *, Char **));
+static void limtail __P((Char *, char *));
+static void plim __P((struct limits *, Char));
+static int setlim __P((struct limits *, Char, RLIM_TYPE));
+
+static struct limits *
+findlim(cp)
+    Char   *cp;
+{
+    register struct limits *lp, *res;
+
+    res = (struct limits *) NULL;
+    for (lp = limits; lp->limconst >= 0; lp++)
+	if (prefix(cp, str2short(lp->limname))) {
+	    if (res)
+		stderror(ERR_NAME | ERR_AMBIG);
+	    res = lp;
+	}
+    if (res)
+	return (res);
+    stderror(ERR_NAME | ERR_LIMIT);
+    /* NOTREACHED */
+    return (0);
+}
+
+void
+/*ARGSUSED*/
+dolimit(v, t)
+    Char **v;
+    struct command *t;
+{
+    register struct limits *lp;
+    register RLIM_TYPE limit;
+    char    hard = 0;
+
+    v++;
+    if (*v && eq(*v, STRmh)) {
+	hard = 1;
+	v++;
+    }
+    if (*v == 0) {
+	for (lp = limits; lp->limconst >= 0; lp++)
+	    plim(lp, hard);
+	return;
+    }
+    lp = findlim(v[0]);
+    if (v[1] == 0) {
+	plim(lp, hard);
+	return;
+    }
+    limit = getval(lp, v + 1);
+    if (setlim(lp, hard, limit) < 0)
+	stderror(ERR_SILENT);
+}
+
+static  RLIM_TYPE
+getval(lp, v)
+    register struct limits *lp;
+    Char  **v;
+{
+    register float f;
+    double  atof();
+    Char   *cp = *v++;
+
+    f = atof(short2str(cp));
+
+    while (Isdigit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E')
+	cp++;
+    if (*cp == 0) {
+	if (*v == 0)
+	    return ((RLIM_TYPE) ((f + 0.5) * lp->limdiv));
+	cp = *v;
+    }
+    switch (*cp) {
+    case ':':
+	if (lp->limconst != RLIMIT_CPU)
+	    goto badscal;
+	return ((RLIM_TYPE) (f * 60.0 + atof(short2str(cp + 1))));
+    case 'h':
+	if (lp->limconst != RLIMIT_CPU)
+	    goto badscal;
+	limtail(cp, "hours");
+	f *= 3600.0;
+	break;
+    case 'm':
+	if (lp->limconst == RLIMIT_CPU) {
+	    limtail(cp, "minutes");
+	    f *= 60.0;
+	    break;
+	}
+	*cp = 'm';
+	limtail(cp, "megabytes");
+	f *= 1024.0 * 1024.0;
+	break;
+    case 's':
+	if (lp->limconst != RLIMIT_CPU)
+	    goto badscal;
+	limtail(cp, "seconds");
+	break;
+    case 'M':
+	if (lp->limconst == RLIMIT_CPU)
+	    goto badscal;
+	*cp = 'm';
+	limtail(cp, "megabytes");
+	f *= 1024.0 * 1024.0;
+	break;
+    case 'k':
+	if (lp->limconst == RLIMIT_CPU)
+	    goto badscal;
+	limtail(cp, "kbytes");
+	f *= 1024.0;
+	break;
+    case 'u':
+	limtail(cp, "unlimited");
+	return (RLIM_INFINITY);
+    default:
+badscal:
+	stderror(ERR_NAME | ERR_SCALEF);
+    }
+    f += 0.5;
+    if (f > (float) RLIM_INFINITY)
+	return RLIM_INFINITY;
+    else
+	return ((RLIM_TYPE) f);
+}
+
+static void
+limtail(cp, str)
+    Char   *cp;
+    char   *str;
+{
+    while (*cp && *cp == *str)
+	cp++, str++;
+    if (*cp)
+	stderror(ERR_BADSCALE, str);
+}
+
+
+/*ARGSUSED*/
+static void
+plim(lp, hard)
+    register struct limits *lp;
+    Char    hard;
+{
+    struct rlimit rlim;
+    RLIM_TYPE limit;
+
+    (void) fprintf(cshout, "%s \t", lp->limname);
+
+    (void) getrlimit(lp->limconst, &rlim);
+    limit = hard ? rlim.rlim_max : rlim.rlim_cur;
+
+    if (limit == RLIM_INFINITY)
+	(void) fprintf(cshout, "unlimited");
+    else if (lp->limconst == RLIMIT_CPU)
+	psecs((long) limit);
+    else
+	(void) fprintf(cshout, "%ld %s", (long) (limit / lp->limdiv),
+		       lp->limscale);
+    (void) fputc('\n', cshout);
+}
+
+void
+/*ARGSUSED*/
+dounlimit(v, t)
+    Char **v;
+    struct command *t;
+{
+    register struct limits *lp;
+    int     lerr = 0;
+    Char    hard = 0;
+
+    v++;
+    if (*v && eq(*v, STRmh)) {
+	hard = 1;
+	v++;
+    }
+    if (*v == 0) {
+	for (lp = limits; lp->limconst >= 0; lp++)
+	    if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0)
+		lerr++;
+	if (lerr)
+	    stderror(ERR_SILENT);
+	return;
+    }
+    while (*v) {
+	lp = findlim(*v++);
+	if (setlim(lp, hard, (RLIM_TYPE) RLIM_INFINITY) < 0)
+	    stderror(ERR_SILENT);
+    }
+}
+
+static int
+setlim(lp, hard, limit)
+    register struct limits *lp;
+    Char    hard;
+    RLIM_TYPE limit;
+{
+    struct rlimit rlim;
+
+    (void) getrlimit(lp->limconst, &rlim);
+
+    if (hard)
+	rlim.rlim_max = limit;
+    else if (limit == RLIM_INFINITY && geteuid() != 0)
+	rlim.rlim_cur = rlim.rlim_max;
+    else
+	rlim.rlim_cur = limit;
+
+    if (setrlimit(lp->limconst, &rlim) < 0) {
+	(void) fprintf(csherr, "%s: %s: Can't %s%s limit\n", bname, lp->limname,
+		       limit == RLIM_INFINITY ? "remove" : "set",
+		       hard ? " hard" : "");
+	return (-1);
+    }
+    return (0);
+}
+
+void
+/*ARGSUSED*/
+dosuspend(v, t)
+    Char **v;
+    struct command *t;
+{
+    int     ctpgrp;
+
+    void    (*old) ();
+
+    if (loginsh)
+	stderror(ERR_SUSPLOG);
+    untty();
+
+    old = signal(SIGTSTP, SIG_DFL);
+    (void) kill(0, SIGTSTP);
+    /* the shell stops here */
+    (void) signal(SIGTSTP, old);
+
+    if (tpgrp != -1) {
+	ctpgrp = tcgetpgrp(FSHTTY);
+	while  (ctpgrp != opgrp) {
+	    old = signal(SIGTTIN, SIG_DFL);
+	    (void) kill(0, SIGTTIN);
+	    (void) signal(SIGTTIN, old);
+	}
+	(void) setpgid(0, shpgrp);
+	(void) tcsetpgrp(FSHTTY, shpgrp);
+    }
+}
+
+/* This is the dreaded EVAL built-in.
+ *   If you don't fiddle with file descriptors, and reset didfds,
+ *   this command will either ignore redirection inside or outside
+ *   its aguments, e.g. eval "date >x"  vs.  eval "date" >x
+ *   The stuff here seems to work, but I did it by trial and error rather
+ *   than really knowing what was going on.  If tpgrp is zero, we are
+ *   probably a background eval, e.g. "eval date &", and we want to
+ *   make sure that any processes we start stay in our pgrp.
+ *   This is also the case for "time eval date" -- stay in same pgrp.
+ *   Otherwise, under stty tostop, processes will stop in the wrong
+ *   pgrp, with no way for the shell to get them going again.  -IAN!
+ */
+static Char **gv = NULL;
+void
+/*ARGSUSED*/
+doeval(v, t)
+    Char **v;
+    struct command *t;
+{
+    Char  **oevalvec;
+    Char   *oevalp;
+    int     odidfds;
+    jmp_buf osetexit;
+    int     my_reenter;
+    Char  **savegv = gv;
+    int     saveIN;
+    int     saveOUT;
+    int     saveERR;
+    int     oSHIN;
+    int     oSHOUT;
+    int     oSHERR;
+
+    UNREGISTER(v);
+
+    oevalvec = evalvec;
+    oevalp = evalp;
+    odidfds = didfds;
+    oSHIN = SHIN;
+    oSHOUT = SHOUT;
+    oSHERR = SHERR;
+
+    v++;
+    if (*v == 0)
+	return;
+    gflag = 0, tglob(v);
+    if (gflag) {
+	gv = v = globall(v);
+	gargv = 0;
+	if (v == 0)
+	    stderror(ERR_NOMATCH);
+	v = copyblk(v);
+    }
+    else {
+	gv = NULL;
+	v = copyblk(v);
+	trim(v);
+    }
+
+    saveIN = dcopy(SHIN, -1);
+    saveOUT = dcopy(SHOUT, -1);
+    saveERR = dcopy(SHERR, -1);
+
+    getexit(osetexit);
+
+    if ((my_reenter = setexit()) == 0) {
+	evalvec = v;
+	evalp = 0;
+	SHIN = dcopy(0, -1);
+	SHOUT = dcopy(1, -1);
+	SHERR = dcopy(2, -1);
+	didfds = 0;
+	process(0);
+    }
+
+    evalvec = oevalvec;
+    evalp = oevalp;
+    doneinp = 0;
+    didfds = odidfds;
+    (void) close(SHIN);
+    (void) close(SHOUT);
+    (void) close(SHERR);
+    SHIN = dmove(saveIN, oSHIN);
+    SHOUT = dmove(saveOUT, oSHOUT);
+    SHERR = dmove(saveERR, oSHERR);
+    if (gv)
+	blkfree(gv), gv = NULL;
+    resexit(osetexit);
+    gv = savegv;
+    if (my_reenter)
+	stderror(ERR_SILENT);
+}
+
+void
+/*ARGSUSED*/
+doprintf(v, t)
+    Char **v;
+    struct command *t;
+{
+    char **c;
+    extern int progprintf __P((int, char **));
+    int ret;
+
+    ret = progprintf(blklen(v), c = short2blk(v));
+    (void) fflush(cshout);
+    (void) fflush(csherr);
+
+    blkfree((Char **) c);
+    if (ret)
+	stderror(ERR_SILENT);
+}