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