[unix-history] / usr / src / bin / csh / set.c

/*-
 * Copyright (c) 1980, 1991 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
static char sccsid[] = "@(#)set.c	5.12 (Berkeley) 6/14/91";
#endif /* not lint */

#include <sys/types.h>
#include <stdlib.h>
#if __STDC__
# include <stdarg.h>
#else
# include <varargs.h>
#endif

#include "csh.h"
#include "extern.h"

static Char	*getinx __P((Char *, int *));
static void	 asx __P((Char *, int, Char *));
static struct varent 
		*getvx __P((Char *, int));
static Char	*xset __P((Char *, Char ***));
static Char	*operate __P((int, Char *, Char *));
static void	 putn1 __P((int));
static struct varent 
		*madrof __P((Char *, struct varent *));
static void	 unsetv1 __P((struct varent *));
static void	 exportpath __P((Char **));
static void	 balance __P((struct varent *, int, int));


/*
 * C Shell
 */

void
doset(v)
    register Char **v;
{
    register Char *p;
    Char   *vp, op;
    Char  **vecp;
    bool    hadsub;
    int     subscr;

    v++;
    p = *v++;
    if (p == 0) {
	prvars();
	return;
    }
    do {
	hadsub = 0;
	vp = p;
	if (letter(*p))
	    for (; alnum(*p); p++)
		continue;
	if (vp == p || !letter(*vp))
	    stderror(ERR_NAME | ERR_VARBEGIN);
	if ((p - vp) > MAXVARLEN) {
	    stderror(ERR_NAME | ERR_VARTOOLONG);
	    return;
	}
	if (*p == '[') {
	    hadsub++;
	    p = getinx(p, &subscr);
	}
	if (op = *p) {
	    *p++ = 0;
	    if (*p == 0 && *v && **v == '(')
		p = *v++;
	}
	else if (*v && eq(*v, STRequal)) {
	    op = '=', v++;
	    if (*v)
		p = *v++;
	}
	if (op && op != '=')
	    stderror(ERR_NAME | ERR_SYNTAX);
	if (eq(p, STRLparen)) {
	    register Char **e = v;

	    if (hadsub)
		stderror(ERR_NAME | ERR_SYNTAX);
	    for (;;) {
		if (!*e)
		    stderror(ERR_NAME | ERR_MISSING, ')');
		if (**e == ')')
		    break;
		e++;
	    }
	    p = *e;
	    *e = 0;
	    vecp = saveblk(v);
	    set1(vp, vecp, &shvhed);
	    *e = p;
	    v = e + 1;
	}
	else if (hadsub)
	    asx(vp, subscr, Strsave(p));
	else
	    set(vp, Strsave(p));
	if (eq(vp, STRpath)) {
	    exportpath(adrof(STRpath)->vec);
	    dohash();
	}
	else if (eq(vp, STRhistchars)) {
	    register Char *pn = value(STRhistchars);

	    HIST = *pn++;
	    HISTSUB = *pn;
	}
	else if (eq(vp, STRuser)) {
	    Setenv(STRUSER, value(vp));
	    Setenv(STRLOGNAME, value(vp));
	}
	else if (eq(vp, STRwordchars)) {
	    word_chars = value(vp);
	}
	else if (eq(vp, STRterm))
	    Setenv(STRTERM, value(vp));
	else if (eq(vp, STRhome)) {
	    register Char *cp;

	    cp = Strsave(value(vp));	/* get the old value back */

	    /*
	     * convert to cononical pathname (possibly resolving symlinks)
	     */
	    cp = dcanon(cp, cp);

	    set(vp, Strsave(cp));	/* have to save the new val */

	    /* and now mirror home with HOME */
	    Setenv(STRHOME, cp);
	    /* fix directory stack for new tilde home */
	    dtilde();
	    xfree((ptr_t) cp);
	}
#ifdef FILEC
	else if (eq(vp, STRfilec))
	    filec = 1;
#endif
    } while (p = *v++);
}

static Char *
getinx(cp, ip)
    register Char *cp;
    register int *ip;
{

    *ip = 0;
    *cp++ = 0;
    while (*cp && Isdigit(*cp))
	*ip = *ip * 10 + *cp++ - '0';
    if (*cp++ != ']')
	stderror(ERR_NAME | ERR_SUBSCRIPT);
    return (cp);
}

static void
asx(vp, subscr, p)
    Char   *vp;
    int     subscr;
    Char   *p;
{
    register struct varent *v = getvx(vp, subscr);

    xfree((ptr_t) v->vec[subscr - 1]);
    v->vec[subscr - 1] = globone(p, G_APPEND);
}

static struct varent *
getvx(vp, subscr)
    Char   *vp;
    int     subscr;
{
    register struct varent *v = adrof(vp);

    if (v == 0)
	udvar(vp);
    if (subscr < 1 || subscr > blklen(v->vec))
	stderror(ERR_NAME | ERR_RANGE);
    return (v);
}

void
dolet(v)
    Char  **v;
{
    register Char *p;
    Char   *vp, c, op;
    bool    hadsub;
    int     subscr;

    v++;
    p = *v++;
    if (p == 0) {
	prvars();
	return;
    }
    do {
	hadsub = 0;
	vp = p;
	if (letter(*p))
	    for (; alnum(*p); p++)
		continue;
	if (vp == p || !letter(*vp))
	    stderror(ERR_NAME | ERR_VARBEGIN);
	if ((p - vp) > MAXVARLEN)
	    stderror(ERR_NAME | ERR_VARTOOLONG);
	if (*p == '[') {
	    hadsub++;
	    p = getinx(p, &subscr);
	}
	if (*p == 0 && *v)
	    p = *v++;
	if (op = *p)
	    *p++ = 0;
	else
	    stderror(ERR_NAME | ERR_ASSIGN);

	if (*p == '\0' && *v == NULL)
	    stderror(ERR_NAME | ERR_ASSIGN);

	vp = Strsave(vp);
	if (op == '=') {
	    c = '=';
	    p = xset(p, &v);
	}
	else {
	    c = *p++;
	    if (any("+-", c)) {
		if (c != op || *p)
		    stderror(ERR_NAME | ERR_UNKNOWNOP);
		p = Strsave(STR1);
	    }
	    else {
		if (any("<>", op)) {
		    if (c != op)
			stderror(ERR_NAME | ERR_UNKNOWNOP);
		    c = *p++;
		    stderror(ERR_NAME | ERR_SYNTAX);
		}
		if (c != '=')
		    stderror(ERR_NAME | ERR_UNKNOWNOP);
		p = xset(p, &v);
	    }
	}
	if (op == '=')
	    if (hadsub)
		asx(vp, subscr, p);
	    else
		set(vp, p);
	else if (hadsub) {
	    struct varent *gv = getvx(vp, subscr);

	    asx(vp, subscr, operate(op, gv->vec[subscr - 1], p));
	}
	else
	    set(vp, operate(op, value(vp), p));
	if (eq(vp, STRpath)) {
	    exportpath(adrof(STRpath)->vec);
	    dohash();
	}
	xfree((ptr_t) vp);
	if (c != '=')
	    xfree((ptr_t) p);
    } while (p = *v++);
}

static Char *
xset(cp, vp)
    Char   *cp, ***vp;
{
    register Char *dp;

    if (*cp) {
	dp = Strsave(cp);
	--(*vp);
	xfree((ptr_t) ** vp);
	**vp = dp;
    }
    return (putn(exp(vp)));
}

static Char *
operate(op, vp, p)
    int    op;
    Char  *vp, *p;
{
    Char    opr[2];
    Char   *vec[5];
    register Char **v = vec;
    Char  **vecp = v;
    register int i;

    if (op != '=') {
	if (*vp)
	    *v++ = vp;
	opr[0] = op;
	opr[1] = 0;
	*v++ = opr;
	if (op == '<' || op == '>')
	    *v++ = opr;
    }
    *v++ = p;
    *v++ = 0;
    i = exp(&vecp);
    if (*vecp)
	stderror(ERR_NAME | ERR_EXPRESSION);
    return (putn(i));
}

static Char *putp;

Char   *
putn(n)
    register int n;
{
    int     num;
    static Char number[15];

    putp = number;
    if (n < 0) {
	n = -n;
	*putp++ = '-';
    }
    num = 2;			/* confuse lint */
    if (sizeof(int) == num && n == -32768) {
	*putp++ = '3';
	n = 2768;
#ifdef pdp11
    }
#else
    }
    else {
	num = 4;		/* confuse lint */
	if (sizeof(int) == num && n == -2147483648) {
	    *putp++ = '2';
	    n = 147483648;
	}
    }
#endif
    putn1(n);
    *putp = 0;
    return (Strsave(number));
}

static void
putn1(n)
    register int n;
{
    if (n > 9)
	putn1(n / 10);
    *putp++ = n % 10 + '0';
}

int
getn(cp)
    register Char *cp;
{
    register int n;
    int     sign;

    sign = 0;
    if (cp[0] == '+' && cp[1])
	cp++;
    if (*cp == '-') {
	sign++;
	cp++;
	if (!Isdigit(*cp))
	    stderror(ERR_NAME | ERR_BADNUM);
    }
    n = 0;
    while (Isdigit(*cp))
	n = n * 10 + *cp++ - '0';
    if (*cp)
	stderror(ERR_NAME | ERR_BADNUM);
    return (sign ? -n : n);
}

Char   *
value1(var, head)
    Char   *var;
    struct varent *head;
{
    register struct varent *vp;

    vp = adrof1(var, head);
    return (vp == 0 || vp->vec[0] == 0 ? STRNULL : vp->vec[0]);
}

static struct varent *
madrof(pat, vp)
    Char   *pat;
    register struct varent *vp;
{
    register struct varent *vp1;

    for (; vp; vp = vp->v_right) {
	if (vp->v_left && (vp1 = madrof(pat, vp->v_left)))
	    return vp1;
	if (Gmatch(vp->v_name, pat))
	    return vp;
    }
    return vp;
}

struct varent *
adrof1(name, v)
    register Char *name;
    register struct varent *v;
{
    register cmp;

    v = v->v_left;
    while (v && ((cmp = *name - *v->v_name) ||
		 (cmp = Strcmp(name, v->v_name))))
	if (cmp < 0)
	    v = v->v_left;
	else
	    v = v->v_right;
    return v;
}

/*
 * The caller is responsible for putting value in a safe place
 */
void
set(var, val)
    Char   *var, *val;
{
    register Char **vec = (Char **) xmalloc((size_t) (2 * sizeof(Char **)));

    vec[0] = val;
    vec[1] = 0;
    set1(var, vec, &shvhed);
}

void
set1(var, vec, head)
    Char   *var, **vec;
    struct varent *head;
{
    register Char **oldv = vec;

    gflag = 0;
    tglob(oldv);
    if (gflag) {
	vec = globall(oldv);
	if (vec == 0) {
	    blkfree(oldv);
	    stderror(ERR_NAME | ERR_NOMATCH);
	    return;
	}
	blkfree(oldv);
	gargv = 0;
    }
    setq(var, vec, head);
}


void
setq(name, vec, p)
    Char   *name, **vec;
    register struct varent *p;
{
    register struct varent *c;
    register f;

    f = 0;			/* tree hangs off the header's left link */
    while (c = p->v_link[f]) {
	if ((f = *name - *c->v_name) == 0 &&
	    (f = Strcmp(name, c->v_name)) == 0) {
	    blkfree(c->vec);
	    goto found;
	}
	p = c;
	f = f > 0;
    }
    p->v_link[f] = c = (struct varent *) xmalloc((size_t) sizeof(struct varent));
    c->v_name = Strsave(name);
    c->v_bal = 0;
    c->v_left = c->v_right = 0;
    c->v_parent = p;
    balance(p, f, 0);
found:
    trim(c->vec = vec);
}

void
unset(v)
    Char   *v[];
{
    unset1(v, &shvhed);
#ifdef FILEC
    if (adrof(STRfilec) == 0)
	filec = 0;
#endif
    if (adrof(STRhistchars) == 0) {
	HIST = '!';
	HISTSUB = '^';
    }
    if (adrof(STRwordchars) == 0)
	word_chars = STR_WORD_CHARS;
}

void
unset1(v, head)
    register Char *v[];
    struct varent *head;
{
    register struct varent *vp;
    register int cnt;

    while (*++v) {
	cnt = 0;
	while (vp = madrof(*v, head->v_left))
	    unsetv1(vp), cnt++;
	if (cnt == 0)
	    setname(short2str(*v));
    }
}

void
unsetv(var)
    Char   *var;
{
    register struct varent *vp;

    if ((vp = adrof1(var, &shvhed)) == 0)
	udvar(var);
    unsetv1(vp);
}

static void
unsetv1(p)
    register struct varent *p;
{
    register struct varent *c, *pp;
    register f;

    /*
     * Free associated memory first to avoid complications.
     */
    blkfree(p->vec);
    xfree((ptr_t) p->v_name);
    /*
     * If p is missing one child, then we can move the other into where p is.
     * Otherwise, we find the predecessor of p, which is guaranteed to have no
     * right child, copy it into p, and move it's left child into it.
     */
    if (p->v_right == 0)
	c = p->v_left;
    else if (p->v_left == 0)
	c = p->v_right;
    else {
	for (c = p->v_left; c->v_right; c = c->v_right);
	p->v_name = c->v_name;
	p->vec = c->vec;
	p = c;
	c = p->v_left;
    }
    /*
     * Move c into where p is.
     */
    pp = p->v_parent;
    f = pp->v_right == p;
    if (pp->v_link[f] = c)
	c->v_parent = pp;
    /*
     * Free the deleted node, and rebalance.
     */
    xfree((ptr_t) p);
    balance(pp, f, 1);
}

void
setNS(cp)
    Char   *cp;
{
    set(cp, Strsave(STRNULL));
}

void
shift(v)
    register Char **v;
{
    register struct varent *argv;
    register Char *name;

    v++;
    name = *v;
    if (name == 0)
	name = STRargv;
    else
	(void) strip(name);
    argv = adrof(name);
    if (argv == 0)
	udvar(name);
    if (argv->vec[0] == 0)
	stderror(ERR_NAME | ERR_NOMORE);
    lshift(argv->vec, 1);
}

static void
exportpath(val)
    Char  **val;
{
    Char    exppath[BUFSIZ];

    exppath[0] = 0;
    if (val)
	while (*val) {
	    if (Strlen(*val) + Strlen(exppath) + 2 > BUFSIZ) {
		xprintf("Warning: ridiculously long PATH truncated\n");
		break;
	    }
	    (void) Strcat(exppath, *val++);
	    if (*val == 0 || eq(*val, STRRparen))
		break;
	    (void) Strcat(exppath, STRcolon);
	}
    Setenv(STRPATH, exppath);
}

#ifndef lint
 /*
  * Lint thinks these have null effect
  */
 /* macros to do single rotations on node p */
#define rright(p) (\
	t = (p)->v_left,\
	(t)->v_parent = (p)->v_parent,\
	((p)->v_left = t->v_right) ? (t->v_right->v_parent = (p)) : 0,\
	(t->v_right = (p))->v_parent = t,\
	(p) = t)
#define rleft(p) (\
	t = (p)->v_right,\
	(t)->v_parent = (p)->v_parent,\
	((p)->v_right = t->v_left) ? (t->v_left->v_parent = (p)) : 0,\
	(t->v_left = (p))->v_parent = t,\
	(p) = t)
#else
struct varent *
rleft(p)
    struct varent *p;
{
    return (p);
}
struct varent *
rright(p)
    struct varent *p;
{
    return (p);
}

#endif				/* ! lint */


/*
 * Rebalance a tree, starting at p and up.
 * F == 0 means we've come from p's left child.
 * D == 1 means we've just done a delete, otherwise an insert.
 */
static void
balance(p, f, d)
    register struct varent *p;
    register int f, d;
{
    register struct varent *pp;

#ifndef lint
    register struct varent *t;	/* used by the rotate macros */

#endif
    register ff;

    /*
     * Ok, from here on, p is the node we're operating on; pp is it's parent; f
     * is the branch of p from which we have come; ff is the branch of pp which
     * is p.
     */
    for (; pp = p->v_parent; p = pp, f = ff) {
	ff = pp->v_right == p;
	if (f ^ d) {		/* right heavy */
	    switch (p->v_bal) {
	    case -1:		/* was left heavy */
		p->v_bal = 0;
		break;
	    case 0:		/* was balanced */
		p->v_bal = 1;
		break;
	    case 1:		/* was already right heavy */
		switch (p->v_right->v_bal) {
		case 1:	/* sigle rotate */
		    pp->v_link[ff] = rleft(p);
		    p->v_left->v_bal = 0;
		    p->v_bal = 0;
		    break;
		case 0:	/* single rotate */
		    pp->v_link[ff] = rleft(p);
		    p->v_left->v_bal = 1;
		    p->v_bal = -1;
		    break;
		case -1:	/* double rotate */
		    (void) rright(p->v_right);
		    pp->v_link[ff] = rleft(p);
		    p->v_left->v_bal =
			p->v_bal < 1 ? 0 : -1;
		    p->v_right->v_bal =
			p->v_bal > -1 ? 0 : 1;
		    p->v_bal = 0;
		    break;
		}
		break;
	    }
	}
	else {			/* left heavy */
	    switch (p->v_bal) {
	    case 1:		/* was right heavy */
		p->v_bal = 0;
		break;
	    case 0:		/* was balanced */
		p->v_bal = -1;
		break;
	    case -1:		/* was already left heavy */
		switch (p->v_left->v_bal) {
		case -1:	/* single rotate */
		    pp->v_link[ff] = rright(p);
		    p->v_right->v_bal = 0;
		    p->v_bal = 0;
		    break;
		case 0:	/* signle rotate */
		    pp->v_link[ff] = rright(p);
		    p->v_right->v_bal = -1;
		    p->v_bal = 1;
		    break;
		case 1:	/* double rotate */
		    (void) rleft(p->v_left);
		    pp->v_link[ff] = rright(p);
		    p->v_left->v_bal =
			p->v_bal < 1 ? 0 : -1;
		    p->v_right->v_bal =
			p->v_bal > -1 ? 0 : 1;
		    p->v_bal = 0;
		    break;
		}
		break;
	    }
	}
	/*
	 * If from insert, then we terminate when p is balanced. If from
	 * delete, then we terminate when p is unbalanced.
	 */
	if ((p->v_bal == 0) ^ d)
	    break;
    }
}

void
plist(p)
    register struct varent *p;
{
    register struct varent *c;
    register len;

    if (setintr)
	(void) sigsetmask(sigblock((sigset_t) 0) & ~sigmask(SIGINT));

    for (;;) {
	while (p->v_left)
	    p = p->v_left;
x:
	if (p->v_parent == 0)	/* is it the header? */
	    return;
	len = blklen(p->vec);
	xprintf(short2str(p->v_name));
	xputchar('\t');
	if (len != 1)
	    xputchar('(');
	blkpr(p->vec);
	if (len != 1)
	    xputchar(')');
	xputchar('\n');
	if (p->v_right) {
	    p = p->v_right;
	    continue;
	}
	do {
	    c = p;
	    p = p->v_parent;
	} while (p->v_right == c);
	goto x;
    }
}
Commit	Line	Data
adc517a8 WJ	1	/*-
	2	* Copyright (c) 1980, 1991 The Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	* 3. All advertising materials mentioning features or use of this software
	14	* must display the following acknowledgement:
	15	* This product includes software developed by the University of
	16	* California, Berkeley and its contributors.
	17	* 4. Neither the name of the University nor the names of its contributors
	18	* may be used to endorse or promote products derived from this software
	19	* without specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	31	* SUCH DAMAGE.
	32	*/
	33
	34	#ifndef lint
	35	static char sccsid[] = "@(#)set.c 5.12 (Berkeley) 6/14/91";
	36	#endif /* not lint */
	37
	38	#include <sys/types.h>
	39	#include <stdlib.h>
	40	#if __STDC__
	41	# include <stdarg.h>
	42	#else
	43	# include <varargs.h>
	44	#endif
	45
	46	#include "csh.h"
	47	#include "extern.h"
	48
	49	static Char getinx __P((Char , int *));
	50	static void asx __P((Char , int, Char ));
	51	static struct varent
	52	getvx __P((Char , int));
	53	static Char xset __P((Char , Char ***));
	54	static Char operate __P((int, Char , Char *));
	55	static void putn1 __P((int));
	56	static struct varent
	57	madrof __P((Char , struct varent *));
	58	static void unsetv1 __P((struct varent *));
	59	static void exportpath __P((Char **));
	60	static void balance __P((struct varent *, int, int));
	61
	62
	63	/*
	64	* C Shell
65	*/
66
67	void
68	doset(v)
69	register Char **v;
70	{
71	register Char *p;
72	Char *vp, op;
73	Char **vecp;
74	bool hadsub;
75	int subscr;
76
77	v++;
78	p = *v++;
79	if (p == 0) {
80	prvars();
81	return;
82	}
83	do {
84	hadsub = 0;
85	vp = p;
86	if (letter(*p))
87	for (; alnum(*p); p++)
88	continue;
89	if (vp == p \|\| !letter(*vp))
90	stderror(ERR_NAME \| ERR_VARBEGIN);
91	if ((p - vp) > MAXVARLEN) {
92	stderror(ERR_NAME \| ERR_VARTOOLONG);
93	return;
94	}
95	if (*p == '[') {
96	hadsub++;
97	p = getinx(p, &subscr);
98	}
99	if (op = *p) {
100	*p++ = 0;
101	if (p == 0 && v && **v == '(')
102	p = *v++;
103	}
104	else if (v && eq(v, STRequal)) {
105	op = '=', v++;
106	if (*v)
107	p = *v++;
108	}
109	if (op && op != '=')
110	stderror(ERR_NAME \| ERR_SYNTAX);
111	if (eq(p, STRLparen)) {
112	register Char **e = v;
113
114	if (hadsub)
115	stderror(ERR_NAME \| ERR_SYNTAX);
116	for (;;) {
117	if (!*e)
118	stderror(ERR_NAME \| ERR_MISSING, ')');
119	if (**e == ')')
120	break;
121	e++;
122	}
123	p = *e;
124	*e = 0;
125	vecp = saveblk(v);
126	set1(vp, vecp, &shvhed);
127	*e = p;
128	v = e + 1;
129	}
130	else if (hadsub)
131	asx(vp, subscr, Strsave(p));
132	else
133	set(vp, Strsave(p));
134	if (eq(vp, STRpath)) {
135	exportpath(adrof(STRpath)->vec);
136	dohash();
137	}
138	else if (eq(vp, STRhistchars)) {
139	register Char *pn = value(STRhistchars);
140
141	HIST = *pn++;
142	HISTSUB = *pn;
143	}
144	else if (eq(vp, STRuser)) {
145	Setenv(STRUSER, value(vp));
146	Setenv(STRLOGNAME, value(vp));
147	}
148	else if (eq(vp, STRwordchars)) {
149	word_chars = value(vp);
150	}
151	else if (eq(vp, STRterm))
152	Setenv(STRTERM, value(vp));
153	else if (eq(vp, STRhome)) {
154	register Char *cp;
155
156	cp = Strsave(value(vp)); /* get the old value back */
157
158	/*
159	* convert to cononical pathname (possibly resolving symlinks)
160	*/
161	cp = dcanon(cp, cp);
162
163	set(vp, Strsave(cp)); /* have to save the new val */
164
165	/* and now mirror home with HOME */
166	Setenv(STRHOME, cp);
167	/* fix directory stack for new tilde home */
168	dtilde();
169	xfree((ptr_t) cp);
170	}
171	#ifdef FILEC
172	else if (eq(vp, STRfilec))
173	filec = 1;
174	#endif
175	} while (p = *v++);
176	}
177
178	static Char *
179	getinx(cp, ip)
180	register Char *cp;
181	register int *ip;
182	{
183
184	*ip = 0;
185	*cp++ = 0;
186	while (cp && Isdigit(cp))
187	ip = ip * 10 + *cp++ - '0';
188	if (*cp++ != ']')
189	stderror(ERR_NAME \| ERR_SUBSCRIPT);
190	return (cp);
191	}
192
193	static void
194	asx(vp, subscr, p)
195	Char *vp;
196	int subscr;
197	Char *p;
198	{
199	register struct varent *v = getvx(vp, subscr);
200
201	xfree((ptr_t) v->vec[subscr - 1]);
202	v->vec[subscr - 1] = globone(p, G_APPEND);
203	}
204
205	static struct varent *
206	getvx(vp, subscr)
207	Char *vp;
208	int subscr;
209	{
210	register struct varent *v = adrof(vp);
211
212	if (v == 0)
213	udvar(vp);
214	if (subscr < 1 \|\| subscr > blklen(v->vec))
215	stderror(ERR_NAME \| ERR_RANGE);
216	return (v);
217	}
218
219	void
220	dolet(v)
221	Char **v;
222	{
223	register Char *p;
224	Char *vp, c, op;
225	bool hadsub;
226	int subscr;
227
228	v++;
229	p = *v++;
230	if (p == 0) {
231	prvars();
232	return;
233	}
234	do {
235	hadsub = 0;
236	vp = p;
237	if (letter(*p))
238	for (; alnum(*p); p++)
239	continue;
240	if (vp == p \|\| !letter(*vp))
241	stderror(ERR_NAME \| ERR_VARBEGIN);
242	if ((p - vp) > MAXVARLEN)
243	stderror(ERR_NAME \| ERR_VARTOOLONG);
244	if (*p == '[') {
245	hadsub++;
246	p = getinx(p, &subscr);
247	}
248	if (p == 0 && v)
249	p = *v++;
250	if (op = *p)
251	*p++ = 0;
252	else
253	stderror(ERR_NAME \| ERR_ASSIGN);
254
255	if (p == '\0' && v == NULL)
256	stderror(ERR_NAME \| ERR_ASSIGN);
257
258	vp = Strsave(vp);
259	if (op == '=') {
260	c = '=';
261	p = xset(p, &v);
262	}
263	else {
264	c = *p++;
265	if (any("+-", c)) {
266	if (c != op \|\| *p)
267	stderror(ERR_NAME \| ERR_UNKNOWNOP);
268	p = Strsave(STR1);
269	}
270	else {
271	if (any("<>", op)) {
272	if (c != op)
273	stderror(ERR_NAME \| ERR_UNKNOWNOP);
274	c = *p++;
275	stderror(ERR_NAME \| ERR_SYNTAX);
276	}
277	if (c != '=')
278	stderror(ERR_NAME \| ERR_UNKNOWNOP);
279	p = xset(p, &v);
280	}
281	}
282	if (op == '=')
283	if (hadsub)
284	asx(vp, subscr, p);
285	else
286	set(vp, p);
287	else if (hadsub) {
288	struct varent *gv = getvx(vp, subscr);
289
290	asx(vp, subscr, operate(op, gv->vec[subscr - 1], p));
291	}
292	else
293	set(vp, operate(op, value(vp), p));
294	if (eq(vp, STRpath)) {
295	exportpath(adrof(STRpath)->vec);
296	dohash();
297	}
298	xfree((ptr_t) vp);
299	if (c != '=')
300	xfree((ptr_t) p);
301	} while (p = *v++);
302	}
303
304	static Char *
305	xset(cp, vp)
306	Char cp, **vp;
307	{
308	register Char *dp;
309
310	if (*cp) {
311	dp = Strsave(cp);
312	--(*vp);
313	xfree((ptr_t) ** vp);
314	**vp = dp;
315	}
316	return (putn(exp(vp)));
317	}
318
319	static Char *
320	operate(op, vp, p)
321	int op;
322	Char vp, p;
323	{
324	Char opr[2];
325	Char *vec[5];
326	register Char **v = vec;
327	Char **vecp = v;
328	register int i;
329
330	if (op != '=') {
331	if (*vp)
332	*v++ = vp;
333	opr[0] = op;
334	opr[1] = 0;
335	*v++ = opr;
336	if (op == '<' \|\| op == '>')
337	*v++ = opr;
338	}
339	*v++ = p;
340	*v++ = 0;
341	i = exp(&vecp);
342	if (*vecp)
343	stderror(ERR_NAME \| ERR_EXPRESSION);
344	return (putn(i));
345	}
346
347	static Char *putp;
348
349	Char *
350	putn(n)
351	register int n;
352	{
353	int num;
354	static Char number[15];
355
356	putp = number;
357	if (n < 0) {
358	n = -n;
359	*putp++ = '-';
360	}
361	num = 2; /* confuse lint */
362	if (sizeof(int) == num && n == -32768) {
363	*putp++ = '3';
364	n = 2768;
365	#ifdef pdp11
366	}
367	#else
368	}
369	else {
370	num = 4; /* confuse lint */
371	if (sizeof(int) == num && n == -2147483648) {
372	*putp++ = '2';
373	n = 147483648;
374	}
375	}
376	#endif
377	putn1(n);
378	*putp = 0;
379	return (Strsave(number));
380	}
381
382	static void
383	putn1(n)
384	register int n;
385	{
386	if (n > 9)
387	putn1(n / 10);
388	*putp++ = n % 10 + '0';
389	}
390
391	int
392	getn(cp)
393	register Char *cp;
394	{
395	register int n;
396	int sign;
397
398	sign = 0;
399	if (cp[0] == '+' && cp[1])
400	cp++;
401	if (*cp == '-') {
402	sign++;
403	cp++;
404	if (!Isdigit(*cp))
405	stderror(ERR_NAME \| ERR_BADNUM);
406	}
407	n = 0;
408	while (Isdigit(*cp))
409	n = n * 10 + *cp++ - '0';
410	if (*cp)
411	stderror(ERR_NAME \| ERR_BADNUM);
412	return (sign ? -n : n);
413	}
414
415	Char *
416	value1(var, head)
417	Char *var;
418	struct varent *head;
419	{
420	register struct varent *vp;
421
422	vp = adrof1(var, head);
423	return (vp == 0 \|\| vp->vec[0] == 0 ? STRNULL : vp->vec[0]);
424	}
425
426	static struct varent *
427	madrof(pat, vp)
428	Char *pat;
429	register struct varent *vp;
430	{
431	register struct varent *vp1;
432
433	for (; vp; vp = vp->v_right) {
434	if (vp->v_left && (vp1 = madrof(pat, vp->v_left)))
435	return vp1;
436	if (Gmatch(vp->v_name, pat))
437	return vp;
438	}
439	return vp;
440	}
441
442	struct varent *
443	adrof1(name, v)
444	register Char *name;
445	register struct varent *v;
446	{
447	register cmp;
448
449	v = v->v_left;
450	while (v && ((cmp = name - v->v_name) \|\|
451	(cmp = Strcmp(name, v->v_name))))
452	if (cmp < 0)
453	v = v->v_left;
454	else
455	v = v->v_right;
456	return v;
457	}
458
459	/*
460	* The caller is responsible for putting value in a safe place
461	*/
462	void
463	set(var, val)
464	Char var, val;
465	{
466	register Char vec = (Char ) xmalloc((size_t) (2 * sizeof(Char **)));
467
468	vec[0] = val;
469	vec[1] = 0;
470	set1(var, vec, &shvhed);
471	}
472
473	void
474	set1(var, vec, head)
475	Char var, *vec;
476	struct varent *head;
477	{
478	register Char **oldv = vec;
479
480	gflag = 0;
481	tglob(oldv);
482	if (gflag) {
483	vec = globall(oldv);
484	if (vec == 0) {
485	blkfree(oldv);
486	stderror(ERR_NAME \| ERR_NOMATCH);
487	return;
488	}
489	blkfree(oldv);
490	gargv = 0;
491	}
492	setq(var, vec, head);
493	}
494
495
496	void
497	setq(name, vec, p)
498	Char name, *vec;
499	register struct varent *p;
500	{
501	register struct varent *c;
502	register f;
503
504	f = 0; /* tree hangs off the header's left link */
505	while (c = p->v_link[f]) {
506	if ((f = name - c->v_name) == 0 &&
507	(f = Strcmp(name, c->v_name)) == 0) {
508	blkfree(c->vec);
509	goto found;
510	}
511	p = c;
512	f = f > 0;
513	}
514	p->v_link[f] = c = (struct varent *) xmalloc((size_t) sizeof(struct varent));
515	c->v_name = Strsave(name);
516	c->v_bal = 0;
517	c->v_left = c->v_right = 0;
518	c->v_parent = p;
519	balance(p, f, 0);
520	found:
521	trim(c->vec = vec);
522	}
523
524	void
525	unset(v)
526	Char *v[];
527	{
528	unset1(v, &shvhed);
529	#ifdef FILEC
530	if (adrof(STRfilec) == 0)
531	filec = 0;
532	#endif
533	if (adrof(STRhistchars) == 0) {
534	HIST = '!';
535	HISTSUB = '^';
536	}
537	if (adrof(STRwordchars) == 0)
538	word_chars = STR_WORD_CHARS;
539	}
540
541	void
542	unset1(v, head)
543	register Char *v[];
544	struct varent *head;
545	{
546	register struct varent *vp;
547	register int cnt;
548
549	while (*++v) {
550	cnt = 0;
551	while (vp = madrof(*v, head->v_left))
552	unsetv1(vp), cnt++;
553	if (cnt == 0)
554	setname(short2str(*v));
555	}
556	}
557
558	void
559	unsetv(var)
560	Char *var;
561	{
562	register struct varent *vp;
563
564	if ((vp = adrof1(var, &shvhed)) == 0)
565	udvar(var);
566	unsetv1(vp);
567	}
568
569	static void
570	unsetv1(p)
571	register struct varent *p;
572	{
573	register struct varent c, pp;
574	register f;
575
576	/*
577	* Free associated memory first to avoid complications.
578	*/
579	blkfree(p->vec);
580	xfree((ptr_t) p->v_name);
581	/*
582	* If p is missing one child, then we can move the other into where p is.
583	* Otherwise, we find the predecessor of p, which is guaranteed to have no
584	* right child, copy it into p, and move it's left child into it.
585	*/
586	if (p->v_right == 0)
587	c = p->v_left;
588	else if (p->v_left == 0)
589	c = p->v_right;
590	else {
591	for (c = p->v_left; c->v_right; c = c->v_right);
592	p->v_name = c->v_name;
593	p->vec = c->vec;
594	p = c;
595	c = p->v_left;
596	}
597	/*
598	* Move c into where p is.
599	*/
600	pp = p->v_parent;
601	f = pp->v_right == p;
602	if (pp->v_link[f] = c)
603	c->v_parent = pp;
604	/*
605	* Free the deleted node, and rebalance.
606	*/
607	xfree((ptr_t) p);
608	balance(pp, f, 1);
609	}
610
611	void
612	setNS(cp)
613	Char *cp;
614	{
615	set(cp, Strsave(STRNULL));
616	}
617
618	void
619	shift(v)
620	register Char **v;
621	{
622	register struct varent *argv;
623	register Char *name;
624
625	v++;
626	name = *v;
627	if (name == 0)
628	name = STRargv;
629	else
630	(void) strip(name);
631	argv = adrof(name);
632	if (argv == 0)
633	udvar(name);
634	if (argv->vec[0] == 0)
635	stderror(ERR_NAME \| ERR_NOMORE);
636	lshift(argv->vec, 1);
637	}
638
639	static void
640	exportpath(val)
641	Char **val;
642	{
643	Char exppath[BUFSIZ];
644
645	exppath[0] = 0;
646	if (val)
647	while (*val) {
648	if (Strlen(*val) + Strlen(exppath) + 2 > BUFSIZ) {
649	xprintf("Warning: ridiculously long PATH truncated\n");
650	break;
651	}
652	(void) Strcat(exppath, *val++);
653	if (val == 0 \|\| eq(val, STRRparen))
654	break;
655	(void) Strcat(exppath, STRcolon);
656	}
657	Setenv(STRPATH, exppath);
658	}
659
660	#ifndef lint
661	/*
662	* Lint thinks these have null effect
663	*/
664	/* macros to do single rotations on node p */
665	#define rright(p) (\
666	t = (p)->v_left,\
667	(t)->v_parent = (p)->v_parent,\
668	((p)->v_left = t->v_right) ? (t->v_right->v_parent = (p)) : 0,\
669	(t->v_right = (p))->v_parent = t,\
670	(p) = t)
671	#define rleft(p) (\
672	t = (p)->v_right,\
673	(t)->v_parent = (p)->v_parent,\
674	((p)->v_right = t->v_left) ? (t->v_left->v_parent = (p)) : 0,\
675	(t->v_left = (p))->v_parent = t,\
676	(p) = t)
677	#else
678	struct varent *
679	rleft(p)
680	struct varent *p;
681	{
682	return (p);
683	}
684	struct varent *
685	rright(p)
686	struct varent *p;
687	{
688	return (p);
689	}
690
691	#endif /* ! lint */
692
693
694	/*
695	* Rebalance a tree, starting at p and up.
696	* F == 0 means we've come from p's left child.
697	* D == 1 means we've just done a delete, otherwise an insert.
698	*/
699	static void
700	balance(p, f, d)
701	register struct varent *p;
702	register int f, d;
703	{
704	register struct varent *pp;
705
706	#ifndef lint
707	register struct varent t; / used by the rotate macros */
708
709	#endif
710	register ff;
711
712	/*
713	* Ok, from here on, p is the node we're operating on; pp is it's parent; f
714	* is the branch of p from which we have come; ff is the branch of pp which
715	* is p.
716	*/
717	for (; pp = p->v_parent; p = pp, f = ff) {
718	ff = pp->v_right == p;
719	if (f ^ d) { /* right heavy */
720	switch (p->v_bal) {
721	case -1: /* was left heavy */
722	p->v_bal = 0;
723	break;
724	case 0: /* was balanced */
725	p->v_bal = 1;
726	break;
727	case 1: /* was already right heavy */
728	switch (p->v_right->v_bal) {
729	case 1: /* sigle rotate */
730	pp->v_link[ff] = rleft(p);
731	p->v_left->v_bal = 0;
732	p->v_bal = 0;
733	break;
734	case 0: /* single rotate */
735	pp->v_link[ff] = rleft(p);
736	p->v_left->v_bal = 1;
737	p->v_bal = -1;
738	break;
739	case -1: /* double rotate */
740	(void) rright(p->v_right);
741	pp->v_link[ff] = rleft(p);
742	p->v_left->v_bal =
743	p->v_bal < 1 ? 0 : -1;
744	p->v_right->v_bal =
745	p->v_bal > -1 ? 0 : 1;
746	p->v_bal = 0;
747	break;
748	}
749	break;
750	}
751	}
752	else { /* left heavy */
753	switch (p->v_bal) {
754	case 1: /* was right heavy */
755	p->v_bal = 0;
756	break;
757	case 0: /* was balanced */
758	p->v_bal = -1;
759	break;
760	case -1: /* was already left heavy */
761	switch (p->v_left->v_bal) {
762	case -1: /* single rotate */
763	pp->v_link[ff] = rright(p);
764	p->v_right->v_bal = 0;
765	p->v_bal = 0;
766	break;
767	case 0: /* signle rotate */
768	pp->v_link[ff] = rright(p);
769	p->v_right->v_bal = -1;
770	p->v_bal = 1;
771	break;
772	case 1: /* double rotate */
773	(void) rleft(p->v_left);
774	pp->v_link[ff] = rright(p);
775	p->v_left->v_bal =
776	p->v_bal < 1 ? 0 : -1;
777	p->v_right->v_bal =
778	p->v_bal > -1 ? 0 : 1;
779	p->v_bal = 0;
780	break;
781	}
782	break;
783	}
784	}
785	/*
786	* If from insert, then we terminate when p is balanced. If from
787	* delete, then we terminate when p is unbalanced.
788	*/
789	if ((p->v_bal == 0) ^ d)
790	break;
791	}
792	}
793
794	void
795	plist(p)
796	register struct varent *p;
797	{
798	register struct varent *c;
799	register len;
800
801	if (setintr)
802	(void) sigsetmask(sigblock((sigset_t) 0) & ~sigmask(SIGINT));
803
804	for (;;) {
805	while (p->v_left)
806	p = p->v_left;
807	x:
808	if (p->v_parent == 0) /* is it the header? */
809	return;
810	len = blklen(p->vec);
811	xprintf(short2str(p->v_name));
812	xputchar('\t');
813	if (len != 1)
814	xputchar('(');
815	blkpr(p->vec);
816	if (len != 1)
817	xputchar(')');
818	xputchar('\n');
819	if (p->v_right) {
820	p = p->v_right;
821	continue;
822	}
823	do {
824	c = p;
825	p = p->v_parent;
826	} while (p->v_right == c);
827	goto x;
828	}
829	}