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