![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sh.func.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / lbin / csh|
Return to sh.func.c CVS log | Up to [Research Unix] / researchv10no / lbin / csh |
1.1 root 1: static char *sccsid = "@(#)sh.func.c 4.5 81/06/19";
2:
3: #include "sh.h"
4: #include <sys/ioctl.h>
5:
6: /*
7: * C shell
8: */
9:
10: extern int ntty_ld, tty_ld;
11:
12: struct biltins *
13: isbfunc(t)
14: register struct command *t;
15: {
16: register char *cp = t->t_dcom[0];
17: register char *dp;
18: register struct biltins *bp;
19: int dolabel(), dofg1(), dobg1();
20: static struct biltins label = { "", dolabel, 0, 0 };
21: static struct biltins foregnd = { "%job", dofg1, 0, 0 };
22: static struct biltins backgnd = { "%job &", dobg1, 0, 0 };
23:
24: if (lastchr(cp) == ':') {
25: label.bname = cp;
26: return (&label);
27: }
28: if (*cp == '%') {
29: if (t->t_dflg & FAND) {
30: t->t_dflg &= ~FAND;
31: backgnd.bname = cp;
32: return (&backgnd);
33: }
34: foregnd.bname = cp;
35: return (&foregnd);
36: }
37: for (bp = bfunc; dp = bp->bname; bp++) {
38: if (dp[0] == cp[0] && eq(dp, cp))
39: return (bp);
40: if (dp[0] > cp[0])
41: break;
42: }
43: return (0);
44: }
45:
46: func(t, bp)
47: register struct command *t;
48: register struct biltins *bp;
49: {
50: int i;
51:
52: xechoit(t->t_dcom);
53: setname(bp->bname);
54: i = blklen(t->t_dcom) - 1;
55: if (i < bp->minargs)
56: bferr("Too few arguments");
57: if (i > bp->maxargs)
58: bferr("Too many arguments");
59: (*bp->bfunct)(t->t_dcom, t);
60: }
61:
62: dolabel()
63: {
64:
65: }
66:
67: doonintr(v)
68: char **v;
69: {
70: register char *cp;
71: register char *vv = v[1];
72:
73: if (parintr == SIG_IGN)
74: return;
75: if (setintr && intty)
76: bferr("Can't from terminal");
77: cp = gointr, gointr = 0, xfree(cp);
78: if (vv == 0) {
79: if (setintr)
80: sighold(SIGINT);
81: else
82: sigset(SIGINT, SIG_DFL);
83: gointr = 0;
84: } else if (eq((vv = strip(vv)), "-")) {
85: sigset(SIGINT, SIG_IGN);
86: gointr = "-";
87: } else {
88: gointr = savestr(vv);
89: sigset(SIGINT, pintr);
90: }
91: }
92:
93: donohup()
94: {
95:
96: if (intty)
97: bferr("Can't from terminal");
98: if (setintr == 0) {
99: signal(SIGHUP, SIG_IGN);
100: #ifdef CC
101: submit(getpid());
102: #endif
103: }
104: }
105:
106: dozip()
107: {
108:
109: ;
110: }
111:
112: prvars()
113: {
114:
115: plist(&shvhed);
116: }
117:
118: doalias(v)
119: register char **v;
120: {
121: register struct varent *vp;
122: register char *p;
123:
124: v++;
125: p = *v++;
126: if (p == 0)
127: plist(&aliases);
128: else if (*v == 0) {
129: vp = adrof1(strip(p), &aliases);
130: if (vp)
131: blkpr(vp->vec), printf("\n");
132: } else {
133: if (eq(p, "alias") || eq(p, "unalias")) {
134: setname(p);
135: bferr("Too dangerous to alias that");
136: }
137: set1(strip(p), saveblk(v), &aliases);
138: }
139: }
140:
141: unalias(v)
142: char **v;
143: {
144:
145: unset1(v, &aliases);
146: }
147:
148: dologout()
149: {
150:
151: islogin();
152: goodbye();
153: }
154:
155: dologin(v)
156: char **v;
157: {
158:
159: islogin();
160: signal(SIGTERM, parterm);
161: execl("/bin/login", "login", v[1], 0);
162: untty();
163: exit(1);
164: }
165:
166: donewgrp(v)
167: char **v;
168: {
169:
170: if (chkstop == 0 && setintr)
171: panystop(0);
172: signal(SIGTERM, parterm);
173: execl("/bin/newgrp", "newgrp", v[1], 0);
174: execl("/usr/bin/newgrp", "newgrp", v[1], 0);
175: untty();
176: exit(1);
177: }
178:
179: islogin()
180: {
181:
182: if (chkstop == 0 && setintr)
183: panystop(0);
184: if (loginsh)
185: return;
186: error("Not login shell");
187: }
188:
189: doif(v, kp)
190: char **v;
191: struct command *kp;
192: {
193: register int i;
194: register char **vv;
195:
196: v++;
197: i = exp(&v);
198: vv = v;
199: if (*vv == NOSTR)
200: bferr("Empty if");
201: if (eq(*vv, "then")) {
202: if (*++vv)
203: bferr("Improper then");
204: setname("then");
205: /*
206: * If expression was zero, then scan to else,
207: * otherwise just fall into following code.
208: */
209: if (!i)
210: search(ZIF, 0);
211: return;
212: }
213: /*
214: * Simple command attached to this if.
215: * Left shift the node in this tree, munging it
216: * so we can reexecute it.
217: */
218: if (i) {
219: lshift(kp->t_dcom, vv - kp->t_dcom);
220: reexecute(kp);
221: donefds();
222: }
223: }
224:
225: /*
226: * Reexecute a command, being careful not
227: * to redo i/o redirection, which is already set up.
228: */
229: reexecute(kp)
230: register struct command *kp;
231: {
232:
233: kp->t_dflg &= FSAVE;
234: kp->t_dflg |= FREDO;
235: /*
236: * If tty is still ours to arbitrate, arbitrate it;
237: * otherwise dont even set pgrp's as the jobs would
238: * then have no way to get the tty (we can't give it
239: * to them, and our parent wouldn't know their pgrp, etc.
240: */
241: execute(kp, tpgrp > 0 ? tpgrp : -1);
242: }
243:
244: doelse()
245: {
246:
247: search(ZELSE, 0);
248: }
249:
250: dogoto(v)
251: char **v;
252: {
253: register struct whyle *wp;
254: char *lp;
255:
256: /*
257: * While we still can, locate any unknown ends of existing loops.
258: * This obscure code is the WORST result of the fact that we
259: * don't really parse.
260: */
261: for (wp = whyles; wp; wp = wp->w_next)
262: if (wp->w_end == 0) {
263: search(ZBREAK, 0);
264: wp->w_end = btell();
265: } else
266: bseek(wp->w_end);
267: search(ZGOTO, 0, lp = globone(v[1]));
268: xfree(lp);
269: /*
270: * Eliminate loops which were exited.
271: */
272: wfree();
273: }
274:
275: doswitch(v)
276: register char **v;
277: {
278: register char *cp, *lp;
279:
280: v++;
281: if (!*v || *(*v++) != '(')
282: goto syntax;
283: cp = **v == ')' ? "" : *v++;
284: if (*(*v++) != ')')
285: v--;
286: if (*v)
287: syntax:
288: error("Syntax error");
289: search(ZSWITCH, 0, lp = globone(cp));
290: xfree(lp);
291: }
292:
293: dobreak()
294: {
295:
296: if (whyles)
297: toend();
298: else
299: bferr("Not in while/foreach");
300: }
301:
302: doexit(v)
303: char **v;
304: {
305:
306: if (chkstop == 0)
307: panystop(0);
308: /*
309: * Don't DEMAND parentheses here either.
310: */
311: v++;
312: if (*v) {
313: set("status", putn(exp(&v)));
314: if (*v)
315: bferr("Expression syntax");
316: }
317: btoeof();
318: if (intty)
319: close(SHIN);
320: }
321:
322: doforeach(v)
323: register char **v;
324: {
325: register char *cp;
326: register struct whyle *nwp;
327:
328: v++;
329: cp = strip(*v);
330: while (*cp && letter(*cp))
331: cp++;
332: if (*cp || strlen(*v) >= 20)
333: bferr("Invalid variable");
334: cp = *v++;
335: if (v[0][0] != '(' || v[blklen(v) - 1][0] != ')')
336: bferr("Words not ()'ed");
337: v++;
338: gflag = 0, rscan(v, tglob);
339: v = glob(v);
340: if (v == 0)
341: bferr("No match");
342: nwp = (struct whyle *) calloc(1, sizeof *nwp);
343: nwp->w_fe = nwp->w_fe0 = v; gargv = 0;
344: nwp->w_start = btell();
345: nwp->w_fename = savestr(cp);
346: nwp->w_next = whyles;
347: whyles = nwp;
348: /*
349: * Pre-read the loop so as to be more
350: * comprehensible to a terminal user.
351: */
352: if (intty)
353: preread();
354: doagain();
355: }
356:
357: dowhile(v)
358: char **v;
359: {
360: register int status;
361: register bool again = whyles != 0 && whyles->w_start == lineloc &&
362: whyles->w_fename == 0;
363:
364: v++;
365: /*
366: * Implement prereading here also, taking care not to
367: * evaluate the expression before the loop has been read up
368: * from a terminal.
369: */
370: if (intty && !again)
371: status = !exp0(&v, 1);
372: else
373: status = !exp(&v);
374: if (*v)
375: bferr("Expression syntax");
376: if (!again) {
377: register struct whyle *nwp = (struct whyle *) calloc(1, sizeof (*nwp));
378:
379: nwp->w_start = lineloc;
380: nwp->w_end = 0;
381: nwp->w_next = whyles;
382: whyles = nwp;
383: if (intty) {
384: /*
385: * The tty preread
386: */
387: preread();
388: doagain();
389: return;
390: }
391: }
392: if (status)
393: /* We ain't gonna loop no more, no more! */
394: toend();
395: }
396:
397: preread()
398: {
399:
400: whyles->w_end = -1;
401: if (setintr)
402: sigrelse(SIGINT);
403: search(ZBREAK, 0);
404: if (setintr)
405: sighold(SIGINT);
406: whyles->w_end = btell();
407: }
408:
409: doend()
410: {
411:
412: if (!whyles)
413: bferr("Not in while/foreach");
414: whyles->w_end = btell();
415: doagain();
416: }
417:
418: docontin()
419: {
420:
421: if (!whyles)
422: bferr("Not in while/foreach");
423: doagain();
424: }
425:
426: doagain()
427: {
428:
429: /* Repeating a while is simple */
430: if (whyles->w_fename == 0) {
431: bseek(whyles->w_start);
432: return;
433: }
434: /*
435: * The foreach variable list actually has a spurious word
436: * ")" at the end of the w_fe list. Thus we are at the
437: * of the list if one word beyond this is 0.
438: */
439: if (!whyles->w_fe[1]) {
440: dobreak();
441: return;
442: }
443: set(whyles->w_fename, savestr(*whyles->w_fe++));
444: bseek(whyles->w_start);
445: }
446:
447: dorepeat(v, kp)
448: char **v;
449: struct command *kp;
450: {
451: register int i;
452:
453: i = getn(v[1]);
454: if (setintr)
455: sighold(SIGINT);
456: lshift(v, 2);
457: while (i > 0) {
458: if (setintr)
459: sigrelse(SIGINT);
460: reexecute(kp);
461: --i;
462: }
463: donefds();
464: if (setintr)
465: sigrelse(SIGINT);
466: }
467:
468: doswbrk()
469: {
470:
471: search(ZBRKSW, 0);
472: }
473:
474: srchx(cp)
475: register char *cp;
476: {
477: register struct srch *sp;
478:
479: for (sp = srchn; sp->s_name; sp++)
480: if (eq(cp, sp->s_name))
481: return (sp->s_value);
482: return (-1);
483: }
484:
485: char Stype;
486: char *Sgoal;
487:
488: /*VARARGS2*/
489: search(type, level, goal)
490: int type;
491: register int level;
492: char *goal;
493: {
494: char wordbuf[BUFSIZ];
495: register char *aword = wordbuf;
496: register char *cp;
497:
498: Stype = type; Sgoal = goal;
499: if (type == ZGOTO)
500: bseek(0l);
501: do {
502: if (intty && fseekp == feobp)
503: printf("? "), flush();
504: aword[0] = 0, getword(aword);
505: switch (srchx(aword)) {
506:
507: case ZELSE:
508: if (level == 0 && type == ZIF)
509: return;
510: break;
511:
512: case ZIF:
513: while (getword(aword))
514: continue;
515: if ((type == ZIF || type == ZELSE) && eq(aword, "then"))
516: level++;
517: break;
518:
519: case ZENDIF:
520: if (type == ZIF || type == ZELSE)
521: level--;
522: break;
523:
524: case ZFOREACH:
525: case ZWHILE:
526: if (type == ZBREAK)
527: level++;
528: break;
529:
530: case ZEND:
531: if (type == ZBREAK)
532: level--;
533: break;
534:
535: case ZSWITCH:
536: if (type == ZSWITCH || type == ZBRKSW)
537: level++;
538: break;
539:
540: case ZENDSW:
541: if (type == ZSWITCH || type == ZBRKSW)
542: level--;
543: break;
544:
545: case ZLABEL:
546: if (type == ZGOTO && getword(aword) && eq(aword, goal))
547: level = -1;
548: break;
549:
550: default:
551: if (type != ZGOTO && (type != ZSWITCH || level != 0))
552: break;
553: if (lastchr(aword) != ':')
554: break;
555: aword[strlen(aword) - 1] = 0;
556: if (type == ZGOTO && eq(aword, goal) || type == ZSWITCH && eq(aword, "default"))
557: level = -1;
558: break;
559:
560: case ZCASE:
561: if (type != ZSWITCH || level != 0)
562: break;
563: getword(aword);
564: if (lastchr(aword) == ':')
565: aword[strlen(aword) - 1] = 0;
566: cp = strip(Dfix1(aword));
567: if (Gmatch(goal, cp))
568: level = -1;
569: xfree(cp);
570: break;
571:
572: case ZDEFAULT:
573: if (type == ZSWITCH && level == 0)
574: level = -1;
575: break;
576: }
577: getword(NOSTR);
578: } while (level >= 0);
579: }
580:
581: getword(wp)
582: register char *wp;
583: {
584: register int found = 0;
585: register int c, d;
586:
587: c = readc(1);
588: d = 0;
589: do {
590: while (c == ' ' || c == '\t')
591: c = readc(1);
592: if (c == '#')
593: do
594: c = readc(1);
595: while (c >= 0 && c != '\n');
596: if (c < 0)
597: goto past;
598: if (c == '\n') {
599: if (wp)
600: break;
601: return (0);
602: }
603: unreadc(c);
604: found = 1;
605: do {
606: c = readc(1);
607: if (c == '\\' && (c = readc(1)) == '\n')
608: c = ' ';
609: if (any(c, "'\""))
610: if (d == 0)
611: d = c;
612: else if (d == c)
613: d = 0;
614: if (c < 0)
615: goto past;
616: if (wp)
617: *wp++ = c;
618: } while ((d || c != ' ' && c != '\t') && c != '\n');
619: } while (wp == 0);
620: unreadc(c);
621: if (found)
622: *--wp = 0;
623: return (found);
624:
625: past:
626: switch (Stype) {
627:
628: case ZIF:
629: bferr("then/endif not found");
630:
631: case ZELSE:
632: bferr("endif not found");
633:
634: case ZBRKSW:
635: case ZSWITCH:
636: bferr("endsw not found");
637:
638: case ZBREAK:
639: bferr("end not found");
640:
641: case ZGOTO:
642: setname(Sgoal);
643: bferr("label not found");
644: }
645: /*NOTREACHED*/
646: }
647:
648: toend()
649: {
650:
651: if (whyles->w_end == 0) {
652: search(ZBREAK, 0);
653: whyles->w_end = btell() - 1;
654: } else
655: bseek(whyles->w_end);
656: wfree();
657: }
658:
659: wfree()
660: {
661: long o = btell();
662:
663: while (whyles) {
664: register struct whyle *wp = whyles;
665: register struct whyle *nwp = wp->w_next;
666:
667: if (o >= wp->w_start && (wp->w_end == 0 || o < wp->w_end))
668: break;
669: if (wp->w_fe0)
670: blkfree(wp->w_fe0);
671: if (wp->w_fename)
672: xfree(wp->w_fename);
673: xfree((char *)wp);
674: whyles = nwp;
675: }
676: }
677:
678: doecho(v)
679: char **v;
680: {
681:
682: echo(' ', v);
683: }
684:
685: doglob(v)
686: char **v;
687: {
688:
689: echo(0, v);
690: flush();
691: }
692:
693: echo(sep, v)
694: char sep;
695: register char **v;
696: {
697: register char *cp;
698: int nonl = 0;
699:
700: if (setintr)
701: sigrelse(SIGINT);
702: v++;
703: if (*v == 0)
704: return;
705: gflag = 0; rscan(v, tglob);
706: if (gflag) {
707: v = glob(v);
708: if (v == 0)
709: bferr("No match");
710: } else
711: scan(v, trim);
712: if (sep == ' ' && !strcmp(*v, "-n"))
713: nonl++, v++;
714: while (cp = *v++) {
715: register int c;
716:
717: while (c = *cp++)
718: putchar(c | QUOTE);
719: if (*v)
720: putchar(sep | QUOTE);
721: }
722: if (sep && nonl == 0)
723: putchar('\n');
724: else
725: flush();
726: if (setintr)
727: sighold(SIGINT);
728: if (gargv)
729: blkfree(gargv), gargv = 0;
730: }
731:
732: char **environ;
733:
734: dosetenv(v)
735: register char **v;
736: {
737: char *lp = globone(v[2]);
738:
739: setenv(v[1], lp);
740: if (eq(v[1], "PATH")) {
741: importpath(lp);
742: dohash();
743: }
744: xfree(lp);
745: }
746:
747: dounsetenv(v)
748: register char **v;
749: {
750:
751: v++;
752: do
753: unsetenv(*v++);
754: while (*v);
755: }
756:
757: setenv(name, value)
758: char *name, *value;
759: {
760: register char **ep = environ;
761: register char *cp, *dp;
762: char *blk[2], **oep = ep;
763:
764: for (; *ep; ep++) {
765: for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
766: continue;
767: if (*cp != 0 || *dp != '=')
768: continue;
769: cp = strspl("=", value);
770: xfree(*ep);
771: *ep = strspl(name, cp);
772: xfree(cp);
773: scan(ep, trim);
774: return;
775: }
776: blk[0] = strspl(name, "="); blk[1] = 0;
777: environ = blkspl(environ, blk);
778: xfree((char *)oep);
779: setenv(name, value);
780: }
781:
782: unsetenv(name)
783: char *name;
784: {
785: register char **ep = environ;
786: register char *cp, *dp;
787: char **oep = ep;
788:
789: for (; *ep; ep++) {
790: for (cp = name, dp = *ep; *cp && *cp == *dp; cp++, dp++)
791: continue;
792: if (*cp != 0 || *dp != '=')
793: continue;
794: cp = *ep;
795: *ep = 0;
796: environ = blkspl(environ, ep+1);
797: *ep = cp;
798: xfree(cp);
799: xfree((char *)oep);
800: return;
801: }
802: }
803:
804: doumask(v)
805: register char **v;
806: {
807: register char *cp = v[1];
808: register int i;
809:
810: if (cp == 0) {
811: i = umask(0);
812: umask(i);
813: printf("%o\n", i);
814: return;
815: }
816: i = 0;
817: while (digit(*cp) && *cp != '8' && *cp != '9')
818: i = i * 8 + *cp++ - '0';
819: if (*cp || i < 0 || i > 0777)
820: bferr("Improper mask");
821: umask(i);
822: }
823:
824: #include <sys/vlimit.h>
825:
826: struct limits {
827: int limconst;
828: char *limname;
829: int limdiv;
830: char *limscale;
831: } limits[] = {
832: LIM_NORAISE, "noraise", 1, "",
833: LIM_CPU, "cputime", 1, "seconds",
834: LIM_FSIZE, "filesize", 1024, "kbytes",
835: LIM_DATA, "datasize", 1024, "kbytes",
836: LIM_STACK, "stacksize", 1024, "kbytes",
837: LIM_CORE, "coredumpsize", 1024, "kbytes",
838: LIM_MAXRSS, "memoryuse", 1024, "kbytes",
839: -1, 0,
840: };
841:
842: struct limits *
843: findlim(cp)
844: char *cp;
845: {
846: register struct limits *lp, *res;
847:
848: res = 0;
849: for (lp = limits; lp->limconst >= 0; lp++)
850: if (prefix(cp, lp->limname)) {
851: if (res)
852: bferr("Ambiguous");
853: res = lp;
854: }
855: if (res)
856: return (res);
857: bferr("No such limit");
858: }
859:
860: dolimit(v)
861: register char **v;
862: {
863: register struct limits *lp;
864: register int limit;
865:
866: v++;
867: if (*v == 0) {
868: for (lp = limits+1; lp->limconst >= 0; lp++)
869: plim(lp);
870: if (vlimit(LIM_NORAISE, -1) && getuid())
871: printf("Limits cannot be raised\n");
872: return;
873: }
874: lp = findlim(v[0]);
875: if (v[1] == 0) {
876: plim(lp);
877: return;
878: }
879: limit = getval(lp, v+1);
880: setlim(lp, limit);
881: }
882:
883: getval(lp, v)
884: register struct limits *lp;
885: char **v;
886: {
887: register float f;
888: double atof();
889: char *cp = *v++;
890:
891: f = atof(cp);
892: while (digit(*cp) || *cp == '.' || *cp == 'e' || *cp == 'E')
893: cp++;
894: if (*cp == 0) {
895: if (*v == 0)
896: return ((int)(f+0.5) * lp->limdiv);
897: cp = *v;
898: }
899: if (lp->limconst == LIM_NORAISE)
900: goto badscal;
901: switch (*cp) {
902:
903: case ':':
904: if (lp->limconst != LIM_CPU)
905: goto badscal;
906: return ((int)(f * 60.0 + atof(cp+1)));
907:
908: case 'h':
909: if (lp->limconst != LIM_CPU)
910: goto badscal;
911: limtail(cp, "hours");
912: f *= 3600.;
913: break;
914:
915: case 'm':
916: if (lp->limconst == LIM_CPU) {
917: limtail(cp, "minutes");
918: f *= 60.;
919: break;
920: }
921: case 'M':
922: if (lp->limconst == LIM_CPU)
923: goto badscal;
924: *cp = 'm';
925: limtail(cp, "megabytes");
926: f *= 1024.*1024.;
927: break;
928:
929: case 's':
930: if (lp->limconst != LIM_CPU)
931: goto badscal;
932: limtail(cp, "seconds");
933: break;
934:
935: case 'k':
936: if (lp->limconst == LIM_CPU)
937: goto badscal;
938: limtail(cp, "kbytes");
939: f *= 1024;
940: break;
941:
942: case 'u':
943: limtail(cp, "unlimited");
944: return (INFINITY);
945:
946: default:
947: badscal:
948: bferr("Improper or unknown scale factor");
949: }
950: return ((int)(f+0.5));
951: }
952:
953: limtail(cp, str0)
954: char *cp, *str0;
955: {
956: register char *str = str0;
957:
958: while (*cp && *cp == *str)
959: cp++, str++;
960: if (*cp)
961: error("Bad scaling; did you mean ``%s''?", str0);
962: }
963:
964: plim(lp)
965: register struct limits *lp;
966: {
967: register int lim;
968:
969: printf("%s \t", lp->limname);
970: lim = vlimit(lp->limconst, -1);
971: if (lim == INFINITY)
972: printf("unlimited");
973: else if (lp->limconst == LIM_CPU)
974: psecs((long)lim);
975: else
976: printf("%d %s", lim / lp->limdiv, lp->limscale);
977: printf("\n");
978: }
979:
980: dounlimit(v)
981: register char **v;
982: {
983: register struct limits *lp;
984:
985: v++;
986: if (*v == 0) {
987: for (lp = limits+1; lp->limconst >= 0; lp++)
988: setlim(lp, INFINITY);
989: return;
990: }
991: while (*v) {
992: lp = findlim(*v++);
993: setlim(lp, INFINITY);
994: }
995: }
996:
997: setlim(lp, limit)
998: register struct limits *lp;
999: {
1000:
1001: if (vlimit(lp->limconst, limit) < 0)
1002: Perror(bname);
1003: }
1004:
1005: dosuspend()
1006: {
1007: int old, ldisc;
1008: short ctpgrp;
1009: int o;
1010:
1011: if (loginsh)
1012: error("Can't suspend a login shell (yet)");
1013: untty();
1014: old = sigsys(SIGTSTP, SIG_DFL);
1015: kill(0, SIGTSTP);
1016: /* the shell stops here */
1017: sigsys(SIGTSTP, old);
1018: if (tpgrp != -1) {
1019: retry:
1020: ioctl(FSHTTY, TIOCGPGRP, &ctpgrp);
1021: if (ctpgrp != opgrp) {
1022: old = sigsys(SIGTTIN, SIG_DFL);
1023: kill(0, SIGTTIN);
1024: sigsys(SIGTTIN, old);
1025: goto retry;
1026: }
1027: ioctl(FSHTTY, TIOCSPGRP, &shpgrp);
1028: setpgrp(0, shpgrp);
1029: }
1030: o = ioctl(FSHTTY, FIOLOOKLD, 0);
1031: if (o == tty_ld) {
1032: printf("Switching to new tty driver...\n");
1033: oldisc = o;
1034: ldisc = ntty_ld;
1035: if (0 <= ioctl(FSHTTY, FIOPOPLD, 0))
1036: ioctl(FSHTTY, FIOPUSHLD, &ldisc);
1037: }
1038: }
1039:
1040: doeval(v)
1041: char **v;
1042: {
1043: char **oevalvec = evalvec;
1044: char *oevalp = evalp;
1045: jmp_buf osetexit;
1046: int reenter;
1047: char **gv = 0;
1048:
1049: v++;
1050: if (*v == 0)
1051: return;
1052: gflag = 0; rscan(v, tglob);
1053: if (gflag) {
1054: gv = v = glob(v);
1055: gargv = 0;
1056: if (v == 0)
1057: error("No match");
1058: v = copyblk(v);
1059: } else
1060: scan(v, trim);
1061: getexit(osetexit);
1062: reenter = 0;
1063: setexit();
1064: reenter++;
1065: if (reenter == 1) {
1066: evalvec = v;
1067: evalp = 0;
1068: process(0);
1069: }
1070: evalvec = oevalvec;
1071: evalp = oevalp;
1072: doneinp = 0;
1073: if (gv)
1074: blkfree(gv);
1075: resexit(osetexit);
1076: if (reenter >= 2)
1077: error(NOSTR);
1078: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.