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