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