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