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