xref: /dragonfly/contrib/tcsh-6/sh.set.c (revision d8082429) 
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