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