contrib/tcsh/sh.set.c

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