cmd/csh/sh.set.c

/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*  Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved. The Berkeley Software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include "sh.h"
#include "sh.tconst.h"
extern int  didchdir;

/*
 * C Shell
 */

void    asx(tchar *, int, tchar *);
void    putn1(int);
void    set(tchar *, tchar *);
void    set1(tchar *, tchar **, struct varent *);
void    setq(tchar *, tchar **, struct varent *);
void    unset1(tchar *[], struct varent *);
void    unsetv1(struct varent *);
void    exportpath(tchar **);
void    balance(struct varent *, int, int);
tchar   *operate(tchar, tchar *, tchar *);
tchar   *getinx(tchar *, int *);
tchar   *xset(tchar *, tchar ***);
struct varent   *getvx(tchar *, int);

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

#ifdef TRACE
    tprintf("TRACE- doset()\n");
#endif
    v++;
    p = *v++;
    if (p == 0) {
        prvars();
        return;
    }
    do {
        hadsub = 0;
        /*
         * check for proper variable syntax
         * must be alphanumeric, start with a letter and
         * be at most 20 characters
         */
        for (vp = p; alnum(*p); p++)
            continue;
        if (vp == p || !letter(*vp))
            goto setsyn;
        if ((p - vp) > MAX_VAR_LEN)
            bferr("Variable name too long");
        if (*p == '[') {
            hadsub++;
            p = getinx(p, &subscr);
        }
        if (op = *p) {
            *p++ = 0;
            if (*p == 0 && *v && **v == '(')
                p = *v++;
        } else if (*v && eq(*v, S_EQ /* "=" */)) {
            op = '=', v++;
            if (*v)
                p = *v++;
        }
        if (op && op != '=')
setsyn:
            bferr("Syntax error");
        if (eq(p, S_LPAR /* "(" */)) {
            tchar **e = v;

            if (hadsub)
                goto setsyn;
            for (;;) {
                if (!*e)
                    bferr("Missing )");
                if (**e == ')')
                    break;
                e++;
            }
            p = *e;
            *e = 0;
            vecp = saveblk(v);
            set1(vp, vecp, &shvhed);
            *e = p;
            v = e + 1;
        } else if (hadsub) {
            retp = savestr(p);
            asx(vp, subscr, retp);
            xfree(retp);
            retp = 0;
        } else
            set(vp, savestr(p));
        if (eq(vp, S_path /* "path" */)) {
            exportpath(adrof(S_path /* "path" */)->vec);
            dohash(xhash);
        } else if (eq(vp, S_histchars /* "histchars" */)) {
            tchar *p = value(S_histchars /* "histchars" */);
            HIST = *p++;
            HISTSUB = *p;
        } else if (eq(vp, S_user /* "user" */))
            local_setenv(S_USER /* "USER" */, value(vp));
        else if (eq(vp, S_term /* "term" */))
            local_setenv(S_TERM /* "TERM" */, value(vp));
        else if (eq(vp, S_home /* "home" */))
            local_setenv(S_HOME /* "HOME" */, value(vp));
#ifdef FILEC
        else if (eq(vp, S_filec /* "filec" */))
            filec = 1;
        else if (eq(vp, S_cdpath /* "cdpath" */))
            dohash(xhash2);
#endif
    } while (p = *v++);
}

tchar *
getinx(tchar *cp, int *ip)
{

#ifdef TRACE
    tprintf("TRACE- getinx()\n");
#endif
    *ip = 0;
    *cp++ = 0;
    while (*cp && digit(*cp))
        *ip = *ip * 10 + *cp++ - '0';
    if (*cp++ != ']')
        bferr("Subscript error");
    return (cp);
}

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

#ifdef TRACE
    tprintf("TRACE- asx()\n");
#endif
    xfree(v->vec[subscr - 1]);
    v->vec[subscr - 1] = globone(p);
}

struct varent *
getvx(tchar *vp, int subscr)
{
    struct varent *v = adrof(vp);

#ifdef TRACE
    tprintf("TRACE- getvx()\n");
#endif
    if (v == 0)
        udvar(vp);
    if (subscr < 1 || subscr > blklen(v->vec))
        bferr("Subscript out of range");
    return (v);
}

tchar plusplus[2] = { '1', 0 };

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

    v++;
    p = *v++;
    if (p == 0) {
        prvars();
        return;
    }
    do {
        hadsub = 0;
        for (vp = p; alnum(*p); p++)
            continue;
        if (vp == p || !letter(*vp))
            goto letsyn;
        if (*p == '[') {
            hadsub++;
            p = getinx(p, &subscr);
        }
        if (*p == 0 && *v)
            p = *v++;
        if (op = *p)
            *p++ = 0;
        else
            goto letsyn;
        vp = savestr(vp);
        if (op == '=') {
            c = '=';
            p = xset(p, &v);
        } else {
            c = *p++;
            /* if (any(c, "+-")) { */
            if (c == '+' || c == '-') {
                if (c != op || *p)
                    goto letsyn;
                p = plusplus;
            } else {
                /* if (any(op, "<>")) { */
                if (op == '<' || op == '>') {
                    if (c != op)
                        goto letsyn;
                    c = *p++;
letsyn:
                    bferr("Syntax error");
                }
                if (c != '=')
                    goto letsyn;
                p = xset(p, &v);
            }
        }
        if (op == '=')
            if (hadsub)
                asx(vp, subscr, p);
            else
                set(vp, p);
        else
            if (hadsub)
#ifndef V6
                /* avoid bug in vax CC */
                {
                    struct varent *gv = getvx(vp, subscr);

                    asx(vp, subscr, operate(op, gv->vec[subscr - 1], p));
                }
#else
                asx(vp, subscr, operate(op, getvx(vp, subscr)->vec[subscr - 1], p));
#endif
            else
                set(vp, operate(op, value(vp), p));
        if (eq(vp, S_path /* "path" */)) {
            exportpath(adrof(S_path /* "path" */)->vec);
            dohash(xhash);
        }

        if (eq(vp, S_cdpath /* "cdpath" */))
            dohash(xhash2);

        xfree(vp);
        if (c != '=')
            xfree(p);
    } while (p = *v++);
}

tchar *
xset(tchar *cp, tchar ***vp)
{
    tchar *dp;

#ifdef TRACE
    tprintf("TRACE- xset()\n");
#endif
    if (*cp) {
        dp = savestr(cp);
        --(*vp);
        xfree(**vp);
        **vp = dp;
    }
    return (putn(exp(vp)));
}

tchar *
operate(tchar op, tchar *vp, tchar *p)
{
    tchar opr[2];
    tchar *vec[5];
    tchar **v = vec;
    tchar **vecp = v;
    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)
        bferr("Expression syntax");
    return (putn(i));
}

static tchar *putp;

tchar *
putn(int n)
{
    static tchar number[15];

#ifdef TRACE
    tprintf("TRACE- putn()\n");
#endif
    putp = number;
    if (n < 0) {
        n = -n;
        *putp++ = '-';
    }
    if (sizeof (int) == 2 && n == -32768) {
        *putp++ = '3';
        n = 2768;
#ifdef pdp11
    }
#else
    } else if (sizeof (int) == 4 && n == 0x80000000) {
        *putp++ = '2';
        n = 147483648;
    }
#endif
    putn1(n);
    *putp = 0;
    return (savestr(number));
}

void
putn1(int n)
{
#ifdef TRACE
    tprintf("TRACE- putn1()\n");
#endif
    if (n > 9)
        putn1(n / 10);
    *putp++ = n % 10 + '0';
}

int
getn(tchar *cp)
{
    int n;
    int sign;

#ifdef TRACE
    tprintf("TRACE- getn()\n");
#endif
    sign = 0;
    if (cp[0] == '+' && cp[1])
        cp++;
    if (*cp == '-') {
        sign++;
        cp++;
        if (!digit(*cp))
            goto badnum;
    }
    n = 0;
    while (digit(*cp))
        n = n * 10 + *cp++ - '0';
    if (*cp)
        goto badnum;
    return (sign ? -n : n);
badnum:
    bferr("Badly formed number");
    return (0);
}

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

#ifdef TRACE
    tprintf("TRACE- value1()\n");
#endif
    vp = adrof1(var, head);
    return (vp == 0 || vp->vec[0] == 0 ? S_ /* "" */ : vp->vec[0]);
}

struct varent *
madrof(tchar *pat, struct varent *vp)
{
    struct varent *vp1;

#ifdef TRACE
    tprintf("TRACE- madrof()\n");
#endif
    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(tchar *name, struct varent *v)
{
    int cmp;

#ifdef TRACE
    tprintf("TRACE- adrof1()\n");
#endif
    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(tchar *var, tchar *val)
{
    tchar **vec =  (tchar **)xalloc(2 * sizeof (tchar **));

#ifdef TRACE
    tprintf("TRACE- set()\n");
#endif
    vec[0] = onlyread(val) ? savestr(val) : val;
    vec[1] = 0;
    set1(var, vec, &shvhed);
}

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

#ifdef TRACE
    tprintf("TRACE- set1()\n");
#endif
    gflag = 0;
    /*
     * If setting cwd variable via "set cwd=/tmp/something"
     * then do globbing.  But if we are setting the cwd
     * becuz of a cd, chdir, pushd, popd, do not do globbing.
     */
    if ((!(eq(var, S_cwd))) || (eq(var, S_cwd) && (didchdir == 0)))
        {
        tglob(oldv);
        }
    if (gflag) {
        vec = glob(oldv);
        if (vec == 0) {
            bferr("No match");
            blkfree(oldv);
            return;
        }
        blkfree(oldv);
        gargv = 0;
    }
    setq(var, vec, head);
}

void
setq(tchar *name, tchar **vec, struct varent *p)
{
    struct varent *c;
    int f;

#ifdef TRACE
    tprintf("TRACE- setq()\n");
#endif
    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 *)xalloc(sizeof (struct varent));
    c->v_name = savestr(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(tchar *v[])
{

#ifdef TRACE
    tprintf("TRACE- unset()\n");
#endif
    unset1(v, &shvhed);
    if (adrof(S_histchars /* "histchars" */) == 0) {
        HIST = '!';
        HISTSUB = '^';
    }
#ifdef FILEC
    if (adrof(S_filec /* "filec" */) == 0)
        filec = 0;
#endif
}

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

#ifdef TRACE
    tprintf("TRACE- unset1()\n");
#endif
    while (*++v) {
        cnt = 0;
        while (vp = madrof(*v, head->v_left))
            unsetv1(vp), cnt++;
        if (cnt == 0)
            setname(*v);
    }
}

void
unsetv(tchar *var)
{
    struct varent *vp;

#ifdef TRACE
    tprintf("TRACE- unsetv()\n");
#endif
    if ((vp = adrof1(var, &shvhed)) == 0)
        udvar(var);
    unsetv1(vp);
}

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

#ifdef TRACE
    tprintf("TRACE- unsetv1()\n");
#endif
    /*
     * Free associated memory first to avoid complications.
     */
    blkfree(p->vec);
    xfree(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(p);
    balance(pp, f, 1);
}

void
setNS(tchar *cp)
{
#ifdef TRACE
    tprintf("TRACE- setNS()\n");
#endif

    set(cp, S_ /* "" */);
}

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

#ifdef TRACE
    tprintf("TRACE- shift()\n");
#endif
    v++;
    name = *v;
    if (name == 0)
        name = S_argv /* "argv" */;
    else
        (void) strip(name);
    argv = adrof(name);
    if (argv == 0)
        udvar(name);
    if (argv->vec[0] == 0)
        bferr("No more words");
    lshift(argv->vec, 1);
}

void
exportpath(tchar **val)
{
    tchar exppath[PATHSIZ];

#ifdef TRACE
    tprintf("TRACE- exportpath()\n");
#endif
    exppath[0] = 0;
    if (val)
        while (*val) {
            if (strlen_(*val) + strlen_(exppath) + 2 > PATHSIZ) {
                printf("Warning: ridiculously long PATH truncated\n");
                break;
            }
            (void) strcat_(exppath, *val++);
            if (*val == 0 || eq(*val, S_RPAR /* ")" */))
                break;
            (void) strcat_(exppath, S_COLON /* ":" */);
        }
    local_setenv(S_PATH /* "PATH" */, exppath);
}

    /* 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)

/*
 * 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.
 */
void
balance(struct varent *p, int f, int d)
{
    struct varent *pp;
    struct varent *t;       /* used by the rotate macros */
    int ff;

#ifdef TRACE
    tprintf("TRACE- balance()\n");
#endif
    /*
     * 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 */
                    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 */
                    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(struct varent *p)
{
    struct varent *c;
    int len;

#ifdef TRACE
    tprintf("TRACE- plist()\n");
#endif
    if (setintr)
        (void) sigsetmask(sigblock(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);
        printf("%t", p->v_name);
        Putchar('\t');
        if (len != 1)
            Putchar('(');
        blkpr(p->vec);
        if (len != 1)
            Putchar(')');
        Putchar('\n');
        if (p->v_right) {
            p = p->v_right;
            continue;
        }
        do {
            c = p;
            p = p->v_parent;
        } while (p->v_right == c);
        goto x;
    }
}