contrib/tcsh/sh.set.c

   1 /* $Header: /src/pub/tcsh/sh.set.c,v 3.37 2000/07/15 19:58:51 christos Exp $ */
   2 /*
   3  * sh.set.c: Setting and Clearing of variables
   4  */
   5 /*-
   6  * Copyright (c) 1980, 1991 The Regents of the University of California.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed by the University of
  20  *      California, Berkeley and its contributors.
  21  * 4. Neither the name of the University nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  */
  37 #include "sh.h"
  38
  39 RCSID("$Id: sh.set.c,v 3.37 2000/07/15 19:58:51 christos Exp $")
  40
  41 #include "ed.h"
  42 #include "tw.h"
  43
  44 extern Char HistLit;
  45 extern bool GotTermCaps;
  46
  47 static  void             update_vars    __P((Char *));
  48 static  Char            *getinx         __P((Char *, int *));
  49 static  void             asx            __P((Char *, int, Char *));
  50 static  struct varent   *getvx          __P((Char *, int));
  51 static  Char            *xset           __P((Char *, Char ***));
  52 static  Char            *operate        __P((int, Char *, Char *));
  53 static  void             putn1          __P((int));
  54 static  struct varent   *madrof         __P((Char *, struct varent *));
  55 static  void             unsetv1        __P((struct varent *));
  56 static  void             exportpath     __P((Char **));
  57 static  void             balance        __P((struct varent *, int, int));
  58
  59 /*
  60  * C Shell
  61  */
  62
  63 static void
  64 update_vars(vp)
  65     Char *vp;
  66 {
  67     if (eq(vp, STRpath)) {
  68         exportpath(adrof(STRpath)->vec);
  69         dohash(NULL, NULL);
  70     }
  71     else if (eq(vp, STRhistchars)) {
  72         register Char *pn = varval(vp);
  73
  74         HIST = *pn++;
  75         HISTSUB = *pn;
  76     }
  77     else if (eq(vp, STRpromptchars)) {
  78         register Char *pn = varval(vp);
  79
  80         PRCH = *pn++;
  81         PRCHROOT = *pn;
  82     }
  83     else if (eq(vp, STRhistlit)) {
  84         HistLit = 1;
  85     }
  86     else if (eq(vp, STRuser)) {
  87         tsetenv(STRKUSER, varval(vp));
  88         tsetenv(STRLOGNAME, varval(vp));
  89     }
  90     else if (eq(vp, STRgroup)) {
  91         tsetenv(STRKGROUP, varval(vp));
  92     }
  93     else if (eq(vp, STRwordchars)) {
  94         word_chars = varval(vp);
  95     }
  96     else if (eq(vp, STRloginsh)) {
  97         loginsh = 1;
  98     }
  99     else if (eq(vp, STRsymlinks)) {
 100         register Char *pn = varval(vp);
 101
 102         if (eq(pn, STRignore))
 103             symlinks = SYM_IGNORE;
 104         else if (eq(pn, STRexpand))
 105             symlinks = SYM_EXPAND;
 106         else if (eq(pn, STRchase))
 107             symlinks = SYM_CHASE;
 108         else
 109             symlinks = 0;
 110     }
 111     else if (eq(vp, STRterm)) {
 112         Char *cp = varval(vp);
 113         tsetenv(STRKTERM, cp);
 114 #ifdef DOESNT_WORK_RIGHT
 115         cp = getenv("TERMCAP");
 116         if (cp && (*cp != '/')) /* if TERMCAP and not a path */
 117             Unsetenv(STRTERMCAP);
 118 #endif /* DOESNT_WORK_RIGHT */
 119         GotTermCaps = 0;
 120         if (noediting && Strcmp(cp, STRnetwork) != 0 &&
 121             Strcmp(cp, STRunknown) != 0 && Strcmp(cp, STRdumb) != 0) {
 122             editing = 1;
 123             noediting = 0;
 124             set(STRedit, Strsave(STRNULL), VAR_READWRITE);
 125         }
 126         ed_Init();              /* reset the editor */
 127     }
 128     else if (eq(vp, STRhome)) {
 129         register Char *cp;
 130
 131         cp = Strsave(varval(vp));       /* get the old value back */
 132
 133         /*
 134          * convert to cononical pathname (possibly resolving symlinks)
 135          */
 136         cp = dcanon(cp, cp);
 137
 138         set(vp, Strsave(cp), VAR_READWRITE);    /* have to save the new val */
 139
 140         /* and now mirror home with HOME */
 141         tsetenv(STRKHOME, cp);
 142         /* fix directory stack for new tilde home */
 143         dtilde();
 144         xfree((ptr_t) cp);
 145     }
 146     else if (eq(vp, STRedit)) {
 147         editing = 1;
 148         noediting = 0;
 149         /* PWP: add more stuff in here later */
 150     }
 151     else if (eq(vp, STRshlvl)) {
 152         tsetenv(STRKSHLVL, varval(vp));
 153     }
 154     else if (eq(vp, STRbackslash_quote)) {
 155         bslash_quote = 1;
 156     }
 157     else if (eq(vp, STRdirstack)) {
 158         dsetstack();
 159     }
 160     else if (eq(vp, STRrecognize_only_executables)) {
 161         tw_cmd_free();
 162     }
 163 #ifndef HAVENOUTMP
 164     else if (eq(vp, STRwatch)) {
 165         resetwatch();
 166     }
 167 #endif /* HAVENOUTMP */
 168     else if (eq(vp, STRimplicitcd)) {
 169         implicit_cd = ((eq(varval(vp), STRverbose)) ? 2 : 1);
 170     }
 171 #ifdef COLOR_LS_F
 172     else if (eq(vp, STRcolor)) {
 173         set_color_context();
 174     }
 175 #endif /* COLOR_LS_F */
 176 #if defined(KANJI) && defined(SHORT_STRINGS) && defined(DSPMBYTE)
 177     else if(eq(vp, CHECK_MBYTEVAR) || eq(vp, STRnokanji)) {
 178         update_dspmbyte_vars();
 179     }
 180 #endif
 181 #ifdef NLS_CATALOGS
 182     else if (eq(vp, STRcatalog)) {
 183         (void) catclose(catd);
 184         nlsinit();
 185     }
 186 #endif /* NLS_CATALOGS */
 187 }
 188
 189
 190 /*ARGSUSED*/
 191 void
 192 doset(v, c)
 193     register Char **v;
 194     struct command *c;
 195 {
 196     register Char *p;
 197     Char   *vp, op;
 198     Char  **vecp;
 199     bool    hadsub;
 200     int     subscr;
 201     int     flags = VAR_READWRITE;
 202     bool    first_match = 0;
 203     bool    last_match = 0;
 204     bool    changed = 0;
 205
 206     USE(c);
 207     v++;
 208     do {
 209         changed = 0;
 210         /*
 211          * Readonly addition From: Tim P. Starrin <noid@cyborg.larc.nasa.gov>
 212          */
 213         if (*v && eq(*v, STRmr)) {
 214             flags = VAR_READONLY;
 215             v++;
 216             changed = 1;
 217         }
 218         if (*v && eq(*v, STRmf) && !last_match) {
 219             first_match = 1;
 220             v++;
 221             changed = 1;
 222         }
 223         if (*v && eq(*v, STRml) && !first_match) {
 224             last_match = 1;
 225             v++;
 226             changed = 1;
 227         }
 228     } while(changed);
 229     p = *v++;
 230     if (p == 0) {
 231         plist(&shvhed, flags);
 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             return;
 245         }
 246         if (*p == '[') {
 247             hadsub++;
 248             p = getinx(p, &subscr);
 249         }
 250         if ((op = *p) != 0) {
 251             *p++ = 0;
 252             if (*p == 0 && *v && **v == '(')
 253                 p = *v++;
 254         }
 255         else if (*v && eq(*v, STRequal)) {
 256             op = '=', v++;
 257             if (*v)
 258                 p = *v++;
 259         }
 260         if (op && op != '=')
 261             stderror(ERR_NAME | ERR_SYNTAX);
 262         if (eq(p, STRLparen)) {
 263             register Char **e = v;
 264
 265             if (hadsub)
 266                 stderror(ERR_NAME | ERR_SYNTAX);
 267             for (;;) {
 268                 if (!*e)
 269                     stderror(ERR_NAME | ERR_MISSING, ')');
 270                 if (**e == ')')
 271                     break;
 272                 e++;
 273             }
 274             p = *e;
 275             *e = 0;
 276             vecp = saveblk(v);
 277             if (first_match)
 278                flags |= VAR_FIRST;
 279             else if (last_match)
 280                flags |= VAR_LAST;
 281
 282             set1(vp, vecp, &shvhed, flags);
 283             *e = p;
 284             v = e + 1;
 285         }
 286         else if (hadsub)
 287             asx(vp, subscr, Strsave(p));
 288         else
 289             set(vp, Strsave(p), flags);
 290         update_vars(vp);
 291     } while ((p = *v++) != NULL);
 292 }
 293
 294 static Char *
 295 getinx(cp, ip)
 296     register Char *cp;
 297     register int *ip;
 298 {
 299     *ip = 0;
 300     *cp++ = 0;
 301     while (*cp && Isdigit(*cp))
 302         *ip = *ip * 10 + *cp++ - '0';
 303     if (*cp++ != ']')
 304         stderror(ERR_NAME | ERR_SUBSCRIPT);
 305     return (cp);
 306 }
 307
 308 static void
 309 asx(vp, subscr, p)
 310     Char   *vp;
 311     int     subscr;
 312     Char   *p;
 313 {
 314     register struct varent *v = getvx(vp, subscr);
 315
 316     if (v->v_flags & VAR_READONLY)
 317         stderror(ERR_READONLY|ERR_NAME, v->v_name);
 318     xfree((ptr_t) v->vec[subscr - 1]);
 319     v->vec[subscr - 1] = globone(p, G_APPEND);
 320 }
 321
 322 static struct varent *
 323 getvx(vp, subscr)
 324     Char   *vp;
 325     int     subscr;
 326 {
 327     register struct varent *v = adrof(vp);
 328
 329     if (v == 0)
 330         udvar(vp);
 331     if (subscr < 1 || subscr > blklen(v->vec))
 332         stderror(ERR_NAME | ERR_RANGE);
 333     return (v);
 334 }
 335
 336 /*ARGSUSED*/
 337 void
 338 dolet(v, dummy)
 339     Char  **v;
 340     struct command *dummy;
 341 {
 342     register Char *p;
 343     Char   *vp, c, op;
 344     bool    hadsub;
 345     int     subscr;
 346
 347     USE(dummy);
 348     v++;
 349     p = *v++;
 350     if (p == 0) {
 351         prvars();
 352         return;
 353     }
 354     do {
 355         hadsub = 0;
 356         vp = p;
 357         if (letter(*p))
 358             for (; alnum(*p); p++)
 359                 continue;
 360         if (vp == p || !letter(*vp))
 361             stderror(ERR_NAME | ERR_VARBEGIN);
 362         if ((p - vp) > MAXVARLEN)
 363             stderror(ERR_NAME | ERR_VARTOOLONG);
 364         if (*p == '[') {
 365             hadsub++;
 366             p = getinx(p, &subscr);
 367         }
 368         if (*p == 0 && *v)
 369             p = *v++;
 370         if ((op = *p) != 0)
 371             *p++ = 0;
 372         else
 373             stderror(ERR_NAME | ERR_ASSIGN);
 374
 375         /*
 376          * if there is no expression after the '=' then print a "Syntax Error"
 377          * message - strike
 378          */
 379         if (*p == '\0' && *v == NULL)
 380             stderror(ERR_NAME | ERR_ASSIGN);
 381
 382         vp = Strsave(vp);
 383         if (op == '=') {
 384             c = '=';
 385             p = xset(p, &v);
 386         }
 387         else {
 388             c = *p++;
 389             if (any("+-", c)) {
 390                 if (c != op || *p)
 391                     stderror(ERR_NAME | ERR_UNKNOWNOP);
 392                 p = Strsave(STR1);
 393             }
 394             else {
 395                 if (any("<>", op)) {
 396                     if (c != op)
 397                         stderror(ERR_NAME | ERR_UNKNOWNOP);
 398                     c = *p++;
 399                     stderror(ERR_NAME | ERR_SYNTAX);
 400                 }
 401                 if (c != '=')
 402                     stderror(ERR_NAME | ERR_UNKNOWNOP);
 403                 p = xset(p, &v);
 404             }
 405         }
 406         if (op == '=') {
 407             if (hadsub)
 408                 asx(vp, subscr, p);
 409             else
 410                 set(vp, p, VAR_READWRITE);
 411         }
 412         else if (hadsub) {
 413             struct varent *gv = getvx(vp, subscr);
 414
 415             asx(vp, subscr, operate(op, gv->vec[subscr - 1], p));
 416         }
 417         else
 418             set(vp, operate(op, varval(vp), p), VAR_READWRITE);
 419         update_vars(vp);
 420         xfree((ptr_t) vp);
 421         if (c != '=')
 422             xfree((ptr_t) p);
 423     } while ((p = *v++) != NULL);
 424 }
 425
 426 static Char *
 427 xset(cp, vp)
 428     Char   *cp, ***vp;
 429 {
 430     register Char *dp;
 431
 432     if (*cp) {
 433         dp = Strsave(cp);
 434         --(*vp);
 435         xfree((ptr_t) ** vp);
 436         **vp = dp;
 437     }
 438     return (putn(expr(vp)));
 439 }
 440
 441 static Char *
 442 operate(op, vp, p)
 443     int     op;
 444     Char    *vp, *p;
 445 {
 446     Char    opr[2];
 447     Char   *vec[5];
 448     register Char **v = vec;
 449     Char  **vecp = v;
 450     register int i;
 451
 452     if (op != '=') {
 453         if (*vp)
 454             *v++ = vp;
 455         opr[0] = (Char) op;
 456         opr[1] = 0;
 457         *v++ = opr;
 458         if (op == '<' || op == '>')
 459             *v++ = opr;
 460     }
 461     *v++ = p;
 462     *v++ = 0;
 463     i = expr(&vecp);
 464     if (*vecp)
 465         stderror(ERR_NAME | ERR_EXPRESSION);
 466     return (putn(i));
 467 }
 468
 469 static Char *putp, nbuf[50];
 470
 471 Char   *
 472 putn(n)
 473     register int n;
 474 {
 475     int     num;
 476
 477     putp = nbuf;
 478     if (n < 0) {
 479         n = -n;
 480         *putp++ = '-';
 481     }
 482     num = 2;                    /* confuse lint */
 483     if (sizeof(int) == num && ((unsigned int) n) == 0x8000) {
 484         *putp++ = '3';
 485         n = 2768;
 486 #ifdef pdp11
 487     }
 488 #else /* !pdp11 */
 489     }
 490     else {
 491         num = 4;                /* confuse lint */
 492         if (sizeof(int) == num && ((unsigned int) n) == 0x80000000) {
 493             *putp++ = '2';
 494             n = 147483648;
 495         }
 496     }
 497 #endif /* pdp11 */
 498     putn1(n);
 499     *putp = 0;
 500     return (Strsave(nbuf));
 501 }
 502
 503 static void
 504 putn1(n)
 505     register int n;
 506 {
 507     if (n > 9)
 508         putn1(n / 10);
 509     *putp++ = n % 10 + '0';
 510 }
 511
 512 int
 513 getn(cp)
 514     register Char *cp;
 515 {
 516     register int n;
 517     int     sign;
 518
 519     if (!cp)                    /* PWP: extra error checking */
 520         stderror(ERR_NAME | ERR_BADNUM);
 521
 522     sign = 0;
 523     if (cp[0] == '+' && cp[1])
 524         cp++;
 525     if (*cp == '-') {
 526         sign++;
 527         cp++;
 528         if (!Isdigit(*cp))
 529             stderror(ERR_NAME | ERR_BADNUM);
 530     }
 531     n = 0;
 532     while (Isdigit(*cp))
 533         n = n * 10 + *cp++ - '0';
 534     if (*cp)
 535         stderror(ERR_NAME | ERR_BADNUM);
 536     return (sign ? -n : n);
 537 }
 538
 539 Char   *
 540 value1(var, head)
 541     Char   *var;
 542     struct varent *head;
 543 {
 544     register struct varent *vp;
 545
 546     if (!var || !head)          /* PWP: extra error checking */
 547         return (STRNULL);
 548
 549     vp = adrof1(var, head);
 550     return (vp == 0 || vp->vec[0] == 0 ? STRNULL : vp->vec[0]);
 551 }
 552
 553 static struct varent *
 554 madrof(pat, vp)
 555     Char   *pat;
 556     register struct varent *vp;
 557 {
 558     register struct varent *vp1;
 559
 560     for (vp = vp->v_left; vp; vp = vp->v_right) {
 561         if (vp->v_left && (vp1 = madrof(pat, vp)) != NULL)
 562             return vp1;
 563         if (Gmatch(vp->v_name, pat))
 564             return vp;
 565     }
 566     return vp;
 567 }
 568
 569 struct varent *
 570 adrof1(name, v)
 571     register Char *name;
 572     register struct varent *v;
 573 {
 574     int cmp;
 575
 576     v = v->v_left;
 577     while (v && ((cmp = *name - *v->v_name) != 0 ||
 578                  (cmp = Strcmp(name, v->v_name)) != 0))
 579         if (cmp < 0)
 580             v = v->v_left;
 581         else
 582             v = v->v_right;
 583     return v;
 584 }
 585
 586 /*
 587  * The caller is responsible for putting value in a safe place
 588  */
 589 void
 590 set(var, val, flags)
 591     Char   *var, *val;
 592     int    flags;
 593 {
 594     register Char **vec = (Char **) xmalloc((size_t) (2 * sizeof(Char **)));
 595
 596     vec[0] = val;
 597     vec[1] = 0;
 598     set1(var, vec, &shvhed, flags);
 599 }
 600
 601 void
 602 set1(var, vec, head, flags)
 603     Char   *var, **vec;
 604     struct varent *head;
 605     int flags;
 606 {
 607     register Char **oldv = vec;
 608
 609     if ((flags & VAR_NOGLOB) == 0) {
 610         gflag = 0;
 611         tglob(oldv);
 612         if (gflag) {
 613             vec = globall(oldv);
 614             if (vec == 0) {
 615                 blkfree(oldv);
 616                 stderror(ERR_NAME | ERR_NOMATCH);
 617                 return;
 618             }
 619             blkfree(oldv);
 620             gargv = 0;
 621         }
 622     }
 623     /*
 624      * Uniqueness addition from: Michael Veksler <mveksler@vnet.ibm.com>
 625      */
 626     if ( flags & (VAR_FIRST | VAR_LAST) ) {
 627         /*
 628          * Code for -f (VAR_FIRST) and -l (VAR_LAST) options.
 629          * Method:
 630          *  Delete all duplicate words leaving "holes" in the word array (vec).
 631          *  Then remove the "holes", keeping the order of the words unchanged.
 632          */
 633         if (vec && vec[0] && vec[1]) { /* more than one word ? */
 634             int i, j;
 635             int num_items;
 636
 637             for (num_items = 0; vec[num_items]; num_items++)
 638                 continue;
 639             if (flags & VAR_FIRST) {
 640                 /* delete duplications, keeping first occurance */
 641                 for (i = 1; i < num_items; i++)
 642                     for (j = 0; j < i; j++)
 643                         /* If have earlier identical item, remove i'th item */
 644                         if (vec[i] && vec[j] && Strcmp(vec[j], vec[i]) == 0) {
 645                             free(vec[i]);
 646                             vec[i] = NULL;
 647                             break;
 648                         }
 649             } else if (flags & VAR_LAST) {
 650               /* delete duplications, keeping last occurance */
 651                 for (i = 0; i < num_items - 1; i++)
 652                     for (j = i + 1; j < num_items; j++)
 653                         /* If have later identical item, remove i'th item */
 654                         if (vec[i] && vec[j] && Strcmp(vec[j], vec[i]) == 0) {
 655                             /* remove identical item (the first) */
 656                             free(vec[i]);
 657                             vec[i] = NULL;
 658                         }
 659             }
 660             /* Compress items - remove empty items */
 661             for (j = i = 0; i < num_items; i++)
 662                if (vec[i])
 663                   vec[j++] = vec[i];
 664
 665             /* NULL-fy remaining items */
 666             for (; j < num_items; j++)
 667                  vec[j] = NULL;
 668         }
 669         /* don't let the attribute propagate */
 670         flags &= ~(VAR_FIRST|VAR_LAST);
 671     }
 672     setq(var, vec, head, flags);
 673 }
 674
 675
 676 void
 677 setq(name, vec, p, flags)
 678     Char   *name, **vec;
 679     register struct varent *p;
 680     int flags;
 681 {
 682     register struct varent *c;
 683     register int f;
 684
 685     f = 0;                      /* tree hangs off the header's left link */
 686     while ((c = p->v_link[f]) != 0) {
 687         if ((f = *name - *c->v_name) == 0 &&
 688             (f = Strcmp(name, c->v_name)) == 0) {
 689             if (c->v_flags & VAR_READONLY)
 690                 stderror(ERR_READONLY|ERR_NAME, c->v_name);
 691             blkfree(c->vec);
 692             c->v_flags = flags;
 693             trim(c->vec = vec);
 694             return;
 695         }
 696         p = c;
 697         f = f > 0;
 698     }
 699     p->v_link[f] = c = (struct varent *) xmalloc((size_t)sizeof(struct varent));
 700     c->v_name = Strsave(name);
 701     c->v_flags = flags;
 702     c->v_bal = 0;
 703     c->v_left = c->v_right = 0;
 704     c->v_parent = p;
 705     balance(p, f, 0);
 706     trim(c->vec = vec);
 707 }
 708
 709 /*ARGSUSED*/
 710 void
 711 unset(v, c)
 712     Char   **v;
 713     struct command *c;
 714 {
 715     bool did_roe, did_edit;
 716
 717     USE(c);
 718     did_roe = adrof(STRrecognize_only_executables) != NULL;
 719     did_edit = adrof(STRedit) != NULL;
 720     unset1(v, &shvhed);
 721     if (adrof(STRhistchars) == 0) {
 722         HIST = '!';
 723         HISTSUB = '^';
 724     }
 725     if (adrof(STRpromptchars) == 0) {
 726         PRCH = '>';
 727         PRCHROOT = '#';
 728     }
 729     if (adrof(STRhistlit) == 0)
 730         HistLit = 0;
 731     if (adrof(STRloginsh) == 0)
 732         loginsh = 0;
 733     if (adrof(STRwordchars) == 0)
 734         word_chars = STR_WORD_CHARS;
 735     if (adrof(STRedit) == 0)
 736         editing = 0;
 737     if (adrof(STRbackslash_quote) == 0)
 738         bslash_quote = 0;
 739     if (adrof(STRsymlinks) == 0)
 740         symlinks = 0;
 741     if (adrof(STRimplicitcd) == 0)
 742         implicit_cd = 0;
 743     if (did_edit && noediting && adrof(STRedit) == 0)
 744         noediting = 0;
 745     if (did_roe && adrof(STRrecognize_only_executables) == 0)
 746         tw_cmd_free();
 747 #ifdef COLOR_LS_F
 748     if (adrof(STRcolor) == 0)
 749         set_color_context();
 750 #endif /* COLOR_LS_F */
 751 #if defined(KANJI) && defined(SHORT_STRINGS) && defined(DSPMBYTE)
 752     update_dspmbyte_vars();
 753 #endif
 754 #ifdef NLS_CATALOGS
 755     (void) catclose(catd);
 756     nlsinit();
 757 #endif /* NLS_CATALOGS */
 758 }
 759
 760 void
 761 unset1(v, head)
 762     register Char *v[];
 763     struct varent *head;
 764 {
 765     register struct varent *vp;
 766     register int cnt;
 767
 768     while (*++v) {
 769         cnt = 0;
 770         while ((vp = madrof(*v, head)) != NULL)
 771             if (vp->v_flags & VAR_READONLY)
 772                 stderror(ERR_READONLY|ERR_NAME, vp->v_name);
 773             else
 774                 unsetv1(vp), cnt++;
 775         if (cnt == 0)
 776             setname(short2str(*v));
 777     }
 778 }
 779
 780 void
 781 unsetv(var)
 782     Char   *var;
 783 {
 784     register struct varent *vp;
 785
 786     if ((vp = adrof1(var, &shvhed)) == 0)
 787         udvar(var);
 788     unsetv1(vp);
 789 }
 790
 791 static void
 792 unsetv1(p)
 793     register struct varent *p;
 794 {
 795     register struct varent *c, *pp;
 796     register int f;
 797
 798     /*
 799      * Free associated memory first to avoid complications.
 800      */
 801     blkfree(p->vec);
 802     xfree((ptr_t) p->v_name);
 803     /*
 804      * If p is missing one child, then we can move the other into where p is.
 805      * Otherwise, we find the predecessor of p, which is guaranteed to have no
 806      * right child, copy it into p, and move it's left child into it.
 807      */
 808     if (p->v_right == 0)
 809         c = p->v_left;
 810     else if (p->v_left == 0)
 811         c = p->v_right;
 812     else {
 813         for (c = p->v_left; c->v_right; c = c->v_right)
 814             continue;
 815         p->v_name = c->v_name;
 816         p->v_flags = c->v_flags;
 817         p->vec = c->vec;
 818         p = c;
 819         c = p->v_left;
 820     }
 821
 822     /*
 823      * Move c into where p is.
 824      */
 825     pp = p->v_parent;
 826     f = pp->v_right == p;
 827     if ((pp->v_link[f] = c) != 0)
 828         c->v_parent = pp;
 829     /*
 830      * Free the deleted node, and rebalance.
 831      */
 832     xfree((ptr_t) p);
 833     balance(pp, f, 1);
 834 }
 835
 836 void
 837 setNS(cp)
 838     Char   *cp;
 839 {
 840     set(cp, Strsave(STRNULL), VAR_READWRITE);
 841 }
 842
 843 /*ARGSUSED*/
 844 void
 845 shift(v, c)
 846     register Char **v;
 847     struct command *c;
 848 {
 849     register struct varent *argv;
 850     register Char *name;
 851
 852     USE(c);
 853     v++;
 854     name = *v;
 855     if (name == 0)
 856         name = STRargv;
 857     else
 858         (void) strip(name);
 859     argv = adrof(name);
 860     if (argv == 0)
 861         udvar(name);
 862     if (argv->vec[0] == 0)
 863         stderror(ERR_NAME | ERR_NOMORE);
 864     lshift(argv->vec, 1);
 865     update_vars(name);
 866 }
 867
 868 static Char STRsep[2] = { PATHSEP, '\0' };
 869
 870 static void
 871 exportpath(val)
 872     Char  **val;
 873 {
 874   Char          *exppath;
 875   size_t        exppath_size = BUFSIZE;
 876   exppath = (Char *)xmalloc(sizeof(Char)*exppath_size);
 877
 878     exppath[0] = 0;
 879     if (val)
 880         while (*val) {
 881           while (Strlen(*val) + Strlen(exppath) + 2 > exppath_size) {
 882             if ((exppath
 883                  = (Char *)xrealloc(exppath, sizeof(Char)*(exppath_size *= 2)))
 884                  == NULL) {
 885                 xprintf(CGETS(18, 1,
 886                               "Warning: ridiculously long PATH truncated\n"));
 887                 break;
 888               }
 889             }
 890             (void) Strcat(exppath, *val++);
 891             if (*val == 0 || eq(*val, STRRparen))
 892               break;
 893             (void) Strcat(exppath, STRsep);
 894           }
 895   tsetenv(STRKPATH, exppath);
 896   free(exppath);
 897 }
 898
 899 #ifndef lint
 900  /*
 901   * Lint thinks these have null effect
 902   */
 903  /* macros to do single rotations on node p */
 904 # define rright(p) (\
 905         t = (p)->v_left,\
 906         (t)->v_parent = (p)->v_parent,\
 907         (((p)->v_left = t->v_right) != NULL) ?\
 908             (t->v_right->v_parent = (p)) : 0,\
 909         (t->v_right = (p))->v_parent = t,\
 910         (p) = t)
 911 # define rleft(p) (\
 912         t = (p)->v_right,\
 913         ((t)->v_parent = (p)->v_parent,\
 914         ((p)->v_right = t->v_left) != NULL) ? \
 915                 (t->v_left->v_parent = (p)) : 0,\
 916         (t->v_left = (p))->v_parent = t,\
 917         (p) = t)
 918 #else
 919 static struct varent *
 920 rleft(p)
 921     struct varent *p;
 922 {
 923     return (p);
 924 }
 925 static struct varent *
 926 rright(p)
 927     struct varent *p;
 928 {
 929     return (p);
 930 }
 931
 932 #endif /* ! lint */
 933
 934
 935 /*
 936  * Rebalance a tree, starting at p and up.
 937  * F == 0 means we've come from p's left child.
 938  * D == 1 means we've just done a delete, otherwise an insert.
 939  */
 940 static void
 941 balance(p, f, d)
 942     register struct varent *p;
 943     register int f, d;
 944 {
 945     register struct varent *pp;
 946
 947 #ifndef lint
 948     register struct varent *t;  /* used by the rotate macros */
 949 #endif /* !lint */
 950     register int ff;
 951 #ifdef lint
 952     ff = 0;     /* Sun's lint is dumb! */
 953 #endif
 954
 955     /*
 956      * Ok, from here on, p is the node we're operating on; pp is it's parent; f
 957      * is the branch of p from which we have come; ff is the branch of pp which
 958      * is p.
 959      */
 960     for (; (pp = p->v_parent) != 0; p = pp, f = ff) {
 961         ff = pp->v_right == p;
 962         if (f ^ d) {            /* right heavy */
 963             switch (p->v_bal) {
 964             case -1:            /* was left heavy */
 965                 p->v_bal = 0;
 966                 break;
 967             case 0:             /* was balanced */
 968                 p->v_bal = 1;
 969                 break;
 970             case 1:             /* was already right heavy */
 971                 switch (p->v_right->v_bal) {
 972                 case 1: /* sigle rotate */
 973                     pp->v_link[ff] = rleft(p);
 974                     p->v_left->v_bal = 0;
 975                     p->v_bal = 0;
 976                     break;
 977                 case 0: /* single rotate */
 978                     pp->v_link[ff] = rleft(p);
 979                     p->v_left->v_bal = 1;
 980                     p->v_bal = -1;
 981                     break;
 982                 case -1:        /* double rotate */
 983                     (void) rright(p->v_right);
 984                     pp->v_link[ff] = rleft(p);
 985                     p->v_left->v_bal =
 986                         p->v_bal < 1 ? 0 : -1;
 987                     p->v_right->v_bal =
 988                         p->v_bal > -1 ? 0 : 1;
 989                     p->v_bal = 0;
 990                     break;
 991                 default:
 992                     break;
 993                 }
 994                 break;
 995             default:
 996                 break;
 997             }
 998         }
 999         else {                  /* left heavy */
1000             switch (p->v_bal) {
1001             case 1:             /* was right heavy */
1002                 p->v_bal = 0;
1003                 break;
1004             case 0:             /* was balanced */
1005                 p->v_bal = -1;
1006                 break;
1007             case -1:            /* was already left heavy */
1008                 switch (p->v_left->v_bal) {
1009                 case -1:        /* single rotate */
1010                     pp->v_link[ff] = rright(p);
1011                     p->v_right->v_bal = 0;
1012                     p->v_bal = 0;
1013                     break;
1014                 case 0: /* signle rotate */
1015                     pp->v_link[ff] = rright(p);
1016                     p->v_right->v_bal = -1;
1017                     p->v_bal = 1;
1018                     break;
1019                 case 1: /* double rotate */
1020                     (void) rleft(p->v_left);
1021                     pp->v_link[ff] = rright(p);
1022                     p->v_left->v_bal =
1023                         p->v_bal < 1 ? 0 : -1;
1024                     p->v_right->v_bal =
1025                         p->v_bal > -1 ? 0 : 1;
1026                     p->v_bal = 0;
1027                     break;
1028                 default:
1029                     break;
1030                 }
1031                 break;
1032             default:
1033                 break;
1034             }
1035         }
1036         /*
1037          * If from insert, then we terminate when p is balanced. If from
1038          * delete, then we terminate when p is unbalanced.
1039          */
1040         if ((p->v_bal == 0) ^ d)
1041             break;
1042     }
1043 }
1044
1045 void
1046 plist(p, what)
1047     register struct varent *p;
1048     int what;
1049 {
1050     register struct varent *c;
1051     register int len;
1052
1053     if (setintr)
1054 #ifdef BSDSIGS
1055         (void) sigsetmask(sigblock((sigmask_t) 0) & ~sigmask(SIGINT));
1056 #else /* !BSDSIGS */
1057         (void) sigrelse(SIGINT);
1058 #endif /* BSDSIGS */
1059
1060     for (;;) {
1061         while (p->v_left)
1062             p = p->v_left;
1063 x:
1064         if (p->v_parent == 0)   /* is it the header? */
1065             return;
1066         if ((p->v_flags & what) != 0) {
1067             len = blklen(p->vec);
1068             xprintf("%S\t", p->v_name);
1069             if (len != 1)
1070                 xputchar('(');
1071             blkpr(p->vec);
1072             if (len != 1)
1073                 xputchar(')');
1074             xputchar('\n');
1075         }
1076         if (p->v_right) {
1077             p = p->v_right;
1078             continue;
1079         }
1080         do {
1081             c = p;
1082             p = p->v_parent;
1083         } while (p->v_right == c);
1084         goto x;
1085     }
1086 }
1087
1088 #if defined(KANJI) && defined(SHORT_STRINGS) && defined(DSPMBYTE)
1089 bool dspmbyte_ls;
1090
1091 void
1092 update_dspmbyte_vars()
1093 {
1094     int lp, iskcode;
1095     Char *dstr1;
1096     struct varent *vp;
1097
1098     /* if variable "nokanji" is set, multi-byte display is disabled */
1099     if ((vp = adrof(CHECK_MBYTEVAR)) && !adrof(STRnokanji)) {
1100         _enable_mbdisp = 1;
1101         dstr1 = vp->vec[0];
1102         if(eq (dstr1, STRKSJIS))
1103             iskcode = 1;
1104         else if (eq(dstr1, STRKEUC))
1105             iskcode = 2;
1106         else if ((dstr1[0] - '0') >= 0 && (dstr1[0] - '0') <= 3) {
1107             iskcode = 0;
1108         }
1109         else {
1110             xprintf(CGETS(18, 2,
1111                "Warning: unknown multibyte display; using default(euc(JP))\n"));
1112             iskcode = 2;
1113         }
1114         if (dstr1 && vp->vec[1] && eq(vp->vec[1], STRls))
1115           dspmbyte_ls = 1;
1116         else
1117           dspmbyte_ls = 0;
1118         for (lp = 0; lp < 256 && iskcode > 0; lp++) {
1119             switch (iskcode) {
1120             case 1:
1121                 /* Shift-JIS */
1122                 _cmap[lp] = _cmap_mbyte[lp];
1123                 _mbmap[lp] = _mbmap_sjis[lp];
1124                 break;
1125             case 2:
1126                 /* 2 ... euc */
1127                 _cmap[lp] = _cmap_mbyte[lp];
1128                 _mbmap[lp] = _mbmap_euc[lp];
1129                 break;
1130             default:
1131                 xprintf(CGETS(18, 3,
1132                     "Warning: unknown multibyte code %d; multibyte disabled\n"),
1133                     iskcode);
1134                 _cmap[lp] = _cmap_c[lp];
1135                 _mbmap[lp] = 0; /* Default map all 0 */
1136                 _enable_mbdisp = 0;
1137                 break;
1138             }
1139         }
1140         if (iskcode == 0) {
1141             /* check original table */
1142             if (Strlen(dstr1) != 256) {
1143                 xprintf(CGETS(18, 4,
1144        "Warning: Invalid multibyte table length (%d); multibyte disabled\n"),
1145                     Strlen(dstr1));
1146                 _enable_mbdisp = 0;
1147             }
1148             for (lp = 0; lp < 256 && _enable_mbdisp == 1; lp++) {
1149                 if (!((dstr1[lp] - '0') >= 0 && (dstr1[lp] - '0') <= 3)) {
1150                     xprintf(CGETS(18, 4,
1151            "Warning: bad multibyte code at offset +%d; multibyte diabled\n"),
1152                         lp);
1153                     _enable_mbdisp = 0;
1154                     break;
1155                 }
1156             }
1157             /* set original table */
1158             for (lp = 0; lp < 256; lp++) {
1159                 if (_enable_mbdisp == 1) {
1160                     _cmap[lp] = _cmap_mbyte[lp];
1161                     _mbmap[lp] = (unsigned short) ((dstr1[lp] - '0') & 0x0f);
1162                 }
1163                 else {
1164                     _cmap[lp] = _cmap_c[lp];
1165                     _mbmap[lp] = 0;     /* Default map all 0 */
1166                 }
1167             }
1168         }
1169     }
1170     else {
1171         for (lp = 0; lp < 256; lp++) {
1172             _cmap[lp] = _cmap_c[lp];
1173             _mbmap[lp] = 0;     /* Default map all 0 */
1174         }
1175         _enable_mbdisp = 0;
1176         dspmbyte_ls = 0;
1177     }
1178 #ifdef MBYTEDEBUG       /* Sorry, use for beta testing */
1179     {
1180         Char mbmapstr[300];
1181         for (lp = 0; lp < 256; lp++) {
1182             mbmapstr[lp] = _mbmap[lp] + '0';
1183             mbmapstr[lp+1] = 0;
1184         }
1185         set(STRmbytemap, Strsave(mbmapstr), VAR_READWRITE);
1186     }
1187 #endif /* MBYTEMAP */
1188 }
1189
1190 /* dspkanji/dspmbyte autosetting */
1191 /* PATCH IDEA FROM Issei.Suzuki VERY THANKS */
1192 void
1193 autoset_dspmbyte(pcp)
1194     Char *pcp;
1195 {
1196     int i;
1197     struct dspm_autoset_Table {
1198         Char *n;
1199         Char *v;
1200     } dspmt[] = {
1201         { STRLANGEUCJP, STRKEUC },
1202         { STRLANGEUCKR, STRKEUC },
1203         { STRLANGEUCJPB, STRKEUC },
1204         { STRLANGEUCKRB, STRKEUC },
1205         { STRLANGSJIS, STRKSJIS },
1206         { STRLANGSJISB, STRKSJIS },
1207         { NULL, NULL }
1208     };
1209
1210     if (*pcp == '\0')
1211         return;
1212
1213     for (i = 0; dspmt[i].n; i++) {
1214         if (eq(pcp, dspmt[i].n)) {
1215             set(CHECK_MBYTEVAR, Strsave(dspmt[i].v), VAR_READWRITE);
1216             update_dspmbyte_vars();
1217             break;
1218         }
1219     }
1220 }
1221 #endif