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