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