1 /*
2 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
3 * Use is subject to license terms.
4 */
5
6 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
7 /* All Rights Reserved */
8
9 /*
10 * Copyright (c) 1980 Regents of the University of California.
11 * All rights reserved. The Berkeley Software License Agreement
12 * specifies the terms and conditions for redistribution.
13 */
14
15 #pragma ident "%Z%%M% %I% %E% SMI"
16
17 #include "sh.h"
18 #include "sh.tconst.h"
19 extern int didchdir;
20
21 /*
22 * C Shell
23 */
24
25 void asx(tchar *, int, tchar *);
26 void putn1(int);
27 void set(tchar *, tchar *);
28 void set1(tchar *, tchar **, struct varent *);
29 void setq(tchar *, tchar **, struct varent *);
30 void unset1(tchar *[], struct varent *);
31 void unsetv1(struct varent *);
32 void exportpath(tchar **);
33 void balance(struct varent *, int, int);
34 tchar *operate(tchar, tchar *, tchar *);
35 tchar *getinx(tchar *, int *);
36 tchar *xset(tchar *, tchar ***);
37 struct varent *getvx(tchar *, int);
38
39 void
doset(tchar ** v)40 doset(tchar **v)
41 {
42 tchar *p;
43 tchar *vp, op;
44 tchar **vecp;
45 bool hadsub;
46 int subscr;
47 tchar *retp;
48
49 #ifdef TRACE
50 tprintf("TRACE- doset()\n");
51 #endif
52 v++;
53 p = *v++;
54 if (p == 0) {
55 prvars();
56 return;
57 }
58 do {
59 hadsub = 0;
60 /*
61 * check for proper variable syntax
62 * must be alphanumeric, start with a letter and
63 * be at most 20 characters
64 */
65 for (vp = p; alnum(*p); p++)
66 continue;
67 if (vp == p || !letter(*vp))
68 goto setsyn;
69 if ((p - vp) > MAX_VAR_LEN)
70 bferr("Variable name too long");
71 if (*p == '[') {
72 hadsub++;
73 p = getinx(p, &subscr);
74 }
75 if (op = *p) {
76 *p++ = 0;
77 if (*p == 0 && *v && **v == '(')
78 p = *v++;
79 } else if (*v && eq(*v, S_EQ /* "=" */)) {
80 op = '=', v++;
81 if (*v)
82 p = *v++;
83 }
84 if (op && op != '=')
85 setsyn:
86 bferr("Syntax error");
87 if (eq(p, S_LPAR /* "(" */)) {
88 tchar **e = v;
89
90 if (hadsub)
91 goto setsyn;
92 for (;;) {
93 if (!*e)
94 bferr("Missing )");
95 if (**e == ')')
96 break;
97 e++;
98 }
99 p = *e;
100 *e = 0;
101 vecp = saveblk(v);
102 set1(vp, vecp, &shvhed);
103 *e = p;
104 v = e + 1;
105 } else if (hadsub) {
106 retp = savestr(p);
107 asx(vp, subscr, retp);
108 xfree(retp);
109 retp = 0;
110 } else
111 set(vp, savestr(p));
112 if (eq(vp, S_path /* "path" */)) {
113 exportpath(adrof(S_path /* "path" */)->vec);
114 dohash(xhash);
115 } else if (eq(vp, S_histchars /* "histchars" */)) {
116 tchar *p = value(S_histchars /* "histchars" */);
117 HIST = *p++;
118 HISTSUB = *p;
119 } else if (eq(vp, S_user /* "user" */))
120 local_setenv(S_USER /* "USER" */, value(vp));
121 else if (eq(vp, S_term /* "term" */))
122 local_setenv(S_TERM /* "TERM" */, value(vp));
123 else if (eq(vp, S_home /* "home" */))
124 local_setenv(S_HOME /* "HOME" */, value(vp));
125 #ifdef FILEC
126 else if (eq(vp, S_filec /* "filec" */))
127 filec = 1;
128 else if (eq(vp, S_cdpath /* "cdpath" */))
129 dohash(xhash2);
130 #endif
131 } while (p = *v++);
132 }
133
134 tchar *
getinx(tchar * cp,int * ip)135 getinx(tchar *cp, int *ip)
136 {
137
138 #ifdef TRACE
139 tprintf("TRACE- getinx()\n");
140 #endif
141 *ip = 0;
142 *cp++ = 0;
143 while (*cp && digit(*cp))
144 *ip = *ip * 10 + *cp++ - '0';
145 if (*cp++ != ']')
146 bferr("Subscript error");
147 return (cp);
148 }
149
150 void
asx(tchar * vp,int subscr,tchar * p)151 asx(tchar *vp, int subscr, tchar *p)
152 {
153 struct varent *v = getvx(vp, subscr);
154
155 #ifdef TRACE
156 tprintf("TRACE- asx()\n");
157 #endif
158 xfree(v->vec[subscr - 1]);
159 v->vec[subscr - 1] = globone(p);
160 }
161
162 struct varent *
getvx(tchar * vp,int subscr)163 getvx(tchar *vp, int subscr)
164 {
165 struct varent *v = adrof(vp);
166
167 #ifdef TRACE
168 tprintf("TRACE- getvx()\n");
169 #endif
170 if (v == 0)
171 udvar(vp);
172 if (subscr < 1 || subscr > blklen(v->vec))
173 bferr("Subscript out of range");
174 return (v);
175 }
176
177 tchar plusplus[2] = { '1', 0 };
178
179 void
dolet(tchar ** v)180 dolet(tchar **v)
181 {
182 tchar *p;
183 tchar *vp, c, op;
184 bool hadsub;
185 int subscr;
186
187 v++;
188 p = *v++;
189 if (p == 0) {
190 prvars();
191 return;
192 }
193 do {
194 hadsub = 0;
195 for (vp = p; alnum(*p); p++)
196 continue;
197 if (vp == p || !letter(*vp))
198 goto letsyn;
199 if (*p == '[') {
200 hadsub++;
201 p = getinx(p, &subscr);
202 }
203 if (*p == 0 && *v)
204 p = *v++;
205 if (op = *p)
206 *p++ = 0;
207 else
208 goto letsyn;
209 vp = savestr(vp);
210 if (op == '=') {
211 c = '=';
212 p = xset(p, &v);
213 } else {
214 c = *p++;
215 /* if (any(c, "+-")) { */
216 if (c == '+' || c == '-') {
217 if (c != op || *p)
218 goto letsyn;
219 p = plusplus;
220 } else {
221 /* if (any(op, "<>")) { */
222 if (op == '<' || op == '>') {
223 if (c != op)
224 goto letsyn;
225 c = *p++;
226 letsyn:
227 bferr("Syntax error");
228 }
229 if (c != '=')
230 goto letsyn;
231 p = xset(p, &v);
232 }
233 }
234 if (op == '=')
235 if (hadsub)
236 asx(vp, subscr, p);
237 else
238 set(vp, p);
239 else
240 if (hadsub)
241 #ifndef V6
242 /* avoid bug in vax CC */
243 {
244 struct varent *gv = getvx(vp, subscr);
245
246 asx(vp, subscr, operate(op, gv->vec[subscr - 1], p));
247 }
248 #else
249 asx(vp, subscr, operate(op, getvx(vp, subscr)->vec[subscr - 1], p));
250 #endif
251 else
252 set(vp, operate(op, value(vp), p));
253 if (eq(vp, S_path /* "path" */)) {
254 exportpath(adrof(S_path /* "path" */)->vec);
255 dohash(xhash);
256 }
257
258 if (eq(vp, S_cdpath /* "cdpath" */))
259 dohash(xhash2);
260
261 xfree(vp);
262 if (c != '=')
263 xfree(p);
264 } while (p = *v++);
265 }
266
267 tchar *
xset(tchar * cp,tchar *** vp)268 xset(tchar *cp, tchar ***vp)
269 {
270 tchar *dp;
271
272 #ifdef TRACE
273 tprintf("TRACE- xset()\n");
274 #endif
275 if (*cp) {
276 dp = savestr(cp);
277 --(*vp);
278 xfree(**vp);
279 **vp = dp;
280 }
281 return (putn(exp(vp)));
282 }
283
284 tchar *
operate(tchar op,tchar * vp,tchar * p)285 operate(tchar op, tchar *vp, tchar *p)
286 {
287 tchar opr[2];
288 tchar *vec[5];
289 tchar **v = vec;
290 tchar **vecp = v;
291 int i;
292
293 if (op != '=') {
294 if (*vp)
295 *v++ = vp;
296 opr[0] = op;
297 opr[1] = 0;
298 *v++ = opr;
299 if (op == '<' || op == '>')
300 *v++ = opr;
301 }
302 *v++ = p;
303 *v++ = 0;
304 i = exp(&vecp);
305 if (*vecp)
306 bferr("Expression syntax");
307 return (putn(i));
308 }
309
310 static tchar *putp;
311
312 tchar *
putn(int n)313 putn(int n)
314 {
315 static tchar number[15];
316
317 #ifdef TRACE
318 tprintf("TRACE- putn()\n");
319 #endif
320 putp = number;
321 if (n < 0) {
322 n = -n;
323 *putp++ = '-';
324 }
325 if (sizeof (int) == 2 && n == -32768) {
326 *putp++ = '3';
327 n = 2768;
328 #ifdef pdp11
329 }
330 #else
331 } else if (sizeof (int) == 4 && n == 0x80000000) {
332 *putp++ = '2';
333 n = 147483648;
334 }
335 #endif
336 putn1(n);
337 *putp = 0;
338 return (savestr(number));
339 }
340
341 void
putn1(int n)342 putn1(int n)
343 {
344 #ifdef TRACE
345 tprintf("TRACE- putn1()\n");
346 #endif
347 if (n > 9)
348 putn1(n / 10);
349 *putp++ = n % 10 + '0';
350 }
351
352 int
getn(tchar * cp)353 getn(tchar *cp)
354 {
355 int n;
356 int sign;
357
358 #ifdef TRACE
359 tprintf("TRACE- getn()\n");
360 #endif
361 sign = 0;
362 if (cp[0] == '+' && cp[1])
363 cp++;
364 if (*cp == '-') {
365 sign++;
366 cp++;
367 if (!digit(*cp))
368 goto badnum;
369 }
370 n = 0;
371 while (digit(*cp))
372 n = n * 10 + *cp++ - '0';
373 if (*cp)
374 goto badnum;
375 return (sign ? -n : n);
376 badnum:
377 bferr("Badly formed number");
378 return (0);
379 }
380
381 tchar *
value1(tchar * var,struct varent * head)382 value1(tchar *var, struct varent *head)
383 {
384 struct varent *vp;
385
386 #ifdef TRACE
387 tprintf("TRACE- value1()\n");
388 #endif
389 vp = adrof1(var, head);
390 return (vp == 0 || vp->vec[0] == 0 ? S_ /* "" */ : vp->vec[0]);
391 }
392
393 struct varent *
madrof(tchar * pat,struct varent * vp)394 madrof(tchar *pat, struct varent *vp)
395 {
396 struct varent *vp1;
397
398 #ifdef TRACE
399 tprintf("TRACE- madrof()\n");
400 #endif
401 for (; vp; vp = vp->v_right) {
402 if (vp->v_left && (vp1 = madrof(pat, vp->v_left)))
403 return vp1;
404 if (Gmatch(vp->v_name, pat))
405 return vp;
406 }
407 return vp;
408 }
409
410 struct varent *
adrof1(tchar * name,struct varent * v)411 adrof1(tchar *name, struct varent *v)
412 {
413 int cmp;
414
415 #ifdef TRACE
416 tprintf("TRACE- adrof1()\n");
417 #endif
418 v = v->v_left;
419 while (v && ((cmp = *name - *v->v_name) ||
420 (cmp = strcmp_(name, v->v_name))))
421 if (cmp < 0)
422 v = v->v_left;
423 else
424 v = v->v_right;
425 return v;
426 }
427
428 /*
429 * The caller is responsible for putting value in a safe place
430 */
431 void
set(tchar * var,tchar * val)432 set(tchar *var, tchar *val)
433 {
434 tchar **vec = (tchar **)xalloc(2 * sizeof (tchar **));
435
436 #ifdef TRACE
437 tprintf("TRACE- set()\n");
438 #endif
439 vec[0] = onlyread(val) ? savestr(val) : val;
440 vec[1] = 0;
441 set1(var, vec, &shvhed);
442 }
443
444 void
set1(tchar * var,tchar ** vec,struct varent * head)445 set1(tchar *var, tchar **vec, struct varent *head)
446 {
447 tchar **oldv = vec;
448
449 #ifdef TRACE
450 tprintf("TRACE- set1()\n");
451 #endif
452 gflag = 0;
453 /*
454 * If setting cwd variable via "set cwd=/tmp/something"
455 * then do globbing. But if we are setting the cwd
456 * becuz of a cd, chdir, pushd, popd, do not do globbing.
457 */
458 if ((!(eq(var, S_cwd))) || (eq(var, S_cwd) && (didchdir == 0)))
459 {
460 tglob(oldv);
461 }
462 if (gflag) {
463 vec = glob(oldv);
464 if (vec == 0) {
465 bferr("No match");
466 blkfree(oldv);
467 return;
468 }
469 blkfree(oldv);
470 gargv = 0;
471 }
472 setq(var, vec, head);
473 }
474
475 void
setq(tchar * name,tchar ** vec,struct varent * p)476 setq(tchar *name, tchar **vec, struct varent *p)
477 {
478 struct varent *c;
479 int f;
480
481 #ifdef TRACE
482 tprintf("TRACE- setq()\n");
483 #endif
484 f = 0; /* tree hangs off the header's left link */
485 while (c = p->v_link[f]) {
486 if ((f = *name - *c->v_name) == 0 &&
487 (f = strcmp_(name, c->v_name)) == 0) {
488 blkfree(c->vec);
489 goto found;
490 }
491 p = c;
492 f = f > 0;
493 }
494 p->v_link[f] = c = (struct varent *)xalloc(sizeof (struct varent));
495 c->v_name = savestr(name);
496 c->v_bal = 0;
497 c->v_left = c->v_right = 0;
498 c->v_parent = p;
499 balance(p, f, 0);
500 found:
501 trim(c->vec = vec);
502 }
503
504 void
unset(tchar * v[])505 unset(tchar *v[])
506 {
507
508 #ifdef TRACE
509 tprintf("TRACE- unset()\n");
510 #endif
511 unset1(v, &shvhed);
512 if (adrof(S_histchars /* "histchars" */) == 0) {
513 HIST = '!';
514 HISTSUB = '^';
515 }
516 #ifdef FILEC
517 if (adrof(S_filec /* "filec" */) == 0)
518 filec = 0;
519 #endif
520 }
521
522 void
unset1(tchar * v[],struct varent * head)523 unset1(tchar *v[], struct varent *head)
524 {
525 struct varent *vp;
526 int cnt;
527
528 #ifdef TRACE
529 tprintf("TRACE- unset1()\n");
530 #endif
531 while (*++v) {
532 cnt = 0;
533 while (vp = madrof(*v, head->v_left))
534 unsetv1(vp), cnt++;
535 if (cnt == 0)
536 setname(*v);
537 }
538 }
539
540 void
unsetv(tchar * var)541 unsetv(tchar *var)
542 {
543 struct varent *vp;
544
545 #ifdef TRACE
546 tprintf("TRACE- unsetv()\n");
547 #endif
548 if ((vp = adrof1(var, &shvhed)) == 0)
549 udvar(var);
550 unsetv1(vp);
551 }
552
553 void
unsetv1(struct varent * p)554 unsetv1(struct varent *p)
555 {
556 struct varent *c, *pp;
557 int f;
558
559 #ifdef TRACE
560 tprintf("TRACE- unsetv1()\n");
561 #endif
562 /*
563 * Free associated memory first to avoid complications.
564 */
565 blkfree(p->vec);
566 xfree(p->v_name);
567 /*
568 * If p is missing one child, then we can move the other
569 * into where p is. Otherwise, we find the predecessor
570 * of p, which is guaranteed to have no right child, copy
571 * it into p, and move it's left child into it.
572 */
573 if (p->v_right == 0)
574 c = p->v_left;
575 else if (p->v_left == 0)
576 c = p->v_right;
577 else {
578 for (c = p->v_left; c->v_right; c = c->v_right)
579 ;
580 p->v_name = c->v_name;
581 p->vec = c->vec;
582 p = c;
583 c = p->v_left;
584 }
585 /*
586 * Move c into where p is.
587 */
588 pp = p->v_parent;
589 f = pp->v_right == p;
590 if (pp->v_link[f] = c)
591 c->v_parent = pp;
592 /*
593 * Free the deleted node, and rebalance.
594 */
595 xfree(p);
596 balance(pp, f, 1);
597 }
598
599 void
setNS(tchar * cp)600 setNS(tchar *cp)
601 {
602 #ifdef TRACE
603 tprintf("TRACE- setNS()\n");
604 #endif
605
606 set(cp, S_ /* "" */);
607 }
608
609 void
shift(tchar ** v)610 shift(tchar **v)
611 {
612 struct varent *argv;
613 tchar *name;
614
615 #ifdef TRACE
616 tprintf("TRACE- shift()\n");
617 #endif
618 v++;
619 name = *v;
620 if (name == 0)
621 name = S_argv /* "argv" */;
622 else
623 (void) strip(name);
624 argv = adrof(name);
625 if (argv == 0)
626 udvar(name);
627 if (argv->vec[0] == 0)
628 bferr("No more words");
629 lshift(argv->vec, 1);
630 }
631
632 void
exportpath(tchar ** val)633 exportpath(tchar **val)
634 {
635 tchar exppath[PATHSIZ];
636
637 #ifdef TRACE
638 tprintf("TRACE- exportpath()\n");
639 #endif
640 exppath[0] = 0;
641 if (val)
642 while (*val) {
643 if (strlen_(*val) + strlen_(exppath) + 2 > PATHSIZ) {
644 printf("Warning: ridiculously long PATH truncated\n");
645 break;
646 }
647 (void) strcat_(exppath, *val++);
648 if (*val == 0 || eq(*val, S_RPAR /* ")" */))
649 break;
650 (void) strcat_(exppath, S_COLON /* ":" */);
651 }
652 local_setenv(S_PATH /* "PATH" */, exppath);
653 }
654
655 /* macros to do single rotations on node p */
656 #define rright(p) (\
657 t = (p)->v_left,\
658 (t)->v_parent = (p)->v_parent,\
659 ((p)->v_left = t->v_right) ? (t->v_right->v_parent = (p)) : 0,\
660 (t->v_right = (p))->v_parent = t,\
661 (p) = t)
662 #define rleft(p) (\
663 t = (p)->v_right,\
664 (t)->v_parent = (p)->v_parent,\
665 ((p)->v_right = t->v_left) ? (t->v_left->v_parent = (p)) : 0,\
666 (t->v_left = (p))->v_parent = t,\
667 (p) = t)
668
669 /*
670 * Rebalance a tree, starting at p and up.
671 * F == 0 means we've come from p's left child.
672 * D == 1 means we've just done a delete, otherwise an insert.
673 */
674 void
balance(struct varent * p,int f,int d)675 balance(struct varent *p, int f, int d)
676 {
677 struct varent *pp;
678 struct varent *t; /* used by the rotate macros */
679 int ff;
680
681 #ifdef TRACE
682 tprintf("TRACE- balance()\n");
683 #endif
684 /*
685 * Ok, from here on, p is the node we're operating on;
686 * pp is it's parent; f is the branch of p from which we have come;
687 * ff is the branch of pp which is p.
688 */
689 for (; pp = p->v_parent; p = pp, f = ff) {
690 ff = pp->v_right == p;
691 if (f ^ d) { /* right heavy */
692 switch (p->v_bal) {
693 case -1: /* was left heavy */
694 p->v_bal = 0;
695 break;
696 case 0: /* was balanced */
697 p->v_bal = 1;
698 break;
699 case 1: /* was already right heavy */
700 switch (p->v_right->v_bal) {
701 case 1: /* sigle rotate */
702 pp->v_link[ff] = rleft(p);
703 p->v_left->v_bal = 0;
704 p->v_bal = 0;
705 break;
706 case 0: /* single rotate */
707 pp->v_link[ff] = rleft(p);
708 p->v_left->v_bal = 1;
709 p->v_bal = -1;
710 break;
711 case -1: /* double rotate */
712 rright(p->v_right);
713 pp->v_link[ff] = rleft(p);
714 p->v_left->v_bal =
715 p->v_bal < 1 ? 0 : -1;
716 p->v_right->v_bal =
717 p->v_bal > -1 ? 0 : 1;
718 p->v_bal = 0;
719 break;
720 }
721 break;
722 }
723 } else { /* left heavy */
724 switch (p->v_bal) {
725 case 1: /* was right heavy */
726 p->v_bal = 0;
727 break;
728 case 0: /* was balanced */
729 p->v_bal = -1;
730 break;
731 case -1: /* was already left heavy */
732 switch (p->v_left->v_bal) {
733 case -1: /* single rotate */
734 pp->v_link[ff] = rright(p);
735 p->v_right->v_bal = 0;
736 p->v_bal = 0;
737 break;
738 case 0: /* signle rotate */
739 pp->v_link[ff] = rright(p);
740 p->v_right->v_bal = -1;
741 p->v_bal = 1;
742 break;
743 case 1: /* double rotate */
744 rleft(p->v_left);
745 pp->v_link[ff] = rright(p);
746 p->v_left->v_bal =
747 p->v_bal < 1 ? 0 : -1;
748 p->v_right->v_bal =
749 p->v_bal > -1 ? 0 : 1;
750 p->v_bal = 0;
751 break;
752 }
753 break;
754 }
755 }
756 /*
757 * If from insert, then we terminate when p is balanced.
758 * If from delete, then we terminate when p is unbalanced.
759 */
760 if ((p->v_bal == 0) ^ d)
761 break;
762 }
763 }
764
765 void
plist(struct varent * p)766 plist(struct varent *p)
767 {
768 struct varent *c;
769 int len;
770
771 #ifdef TRACE
772 tprintf("TRACE- plist()\n");
773 #endif
774 if (setintr)
775 (void) sigsetmask(sigblock(0) & ~ sigmask(SIGINT));
776 for (;;) {
777 while (p->v_left)
778 p = p->v_left;
779 x:
780 if (p->v_parent == 0) /* is it the header? */
781 return;
782 len = blklen(p->vec);
783 printf("%t", p->v_name);
784 Putchar('\t');
785 if (len != 1)
786 Putchar('(');
787 blkpr(p->vec);
788 if (len != 1)
789 Putchar(')');
790 Putchar('\n');
791 if (p->v_right) {
792 p = p->v_right;
793 continue;
794 }
795 do {
796 c = p;
797 p = p->v_parent;
798 } while (p->v_right == c);
799 goto x;
800 }
801 }
802