contrib/tcsh-6/sh.set.c

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