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