![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to exec3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / sh_B4_420|
Return to exec3.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / sh_B4_420 |
1.1 root 1: /*
2: * sh/exec3.c
3: * Bourne shell.
4: * Builtin commands and shell functions.
5: */
6:
7: #include "sh.h"
8: #include <sys/times.h>
9: #include <sys/const.h> /* HZ defined here */
10:
11: #define HOUR (60L*60L*HZ)
12: #define MINUTE (60L*HZ)
13: #define SECOND HZ
14:
15: NODE *copy_node();
16: char *cd();
17:
18: extern s_colon();
19: extern s_dot();
20: extern s_break();
21: #define s_continue s_break
22: extern s_cd();
23: extern s_dirs();
24: extern s_eval();
25: extern s_exec();
26: extern s_exit();
27: extern s_export();
28: extern s_login();
29: #define s_newgrp s_login
30: extern s_popd();
31: extern s_pushd();
32: extern s_read();
33: #define s_readonly s_export
34: extern s_set();
35: extern s_shift();
36: extern s_times();
37: extern s_trap();
38: extern s_umask();
39: extern s_wait();
40: #define SNULL ((int (*)())0)
41:
42: /* Built-in functions. */
43: typedef struct {
44: int i_hash;
45: char *i_name;
46: int (*i_func)();
47: } INLINE;
48:
49: INLINE inls[] = {
50: 0, ":", s_colon,
51: 0, ".", s_dot,
52: 0, "break", s_break,
53: 0, "continue", s_continue,
54: 0, "cd", s_cd,
55: 0, "dirs", s_dirs,
56: 0, "eval", s_eval,
57: 0, "exec", s_exec,
58: 0, "exit", s_exit,
59: 0, "export", s_export,
60: 0, "login", s_login,
61: 0, "newgrp", s_newgrp,
62: 0, "popd", s_popd,
63: 0, "pushd", s_pushd,
64: 0, "read", s_read,
65: 0, "readonly", s_readonly,
66: 0, "set", s_set,
67: 0, "shift", s_shift,
68: 0, "times", s_times,
69: 0, "trap", s_trap,
70: 0, "umask", s_umask,
71: 0, "wait", s_wait,
72: 0, NULL, SNULL
73: };
74:
75: inline()
76: {
77: register int (*s_func)();
78: register INLINE *ip;
79: register int ahash;
80:
81: if (inls[0].i_hash==0)
82: for (ip=inls; ip->i_name!=NULL; ip++)
83: ip->i_hash = ihash(ip->i_name);
84: if (nargv[0] == NULL)
85: return 0;
86: ahash = ihash(nargv[0]);
87: for (ip=inls; ip->i_name!=NULL; ip++)
88: if (ip->i_hash==ahash && strcmp(nargv[0], ip->i_name)==0)
89: break;
90: if ((s_func=ip->i_func) == SNULL)
91: return 0;
92: /*
93: * Process exec specially, because it has unique semantics for
94: * redirection (among other things). Redirection of builtins is done
95: * using the "undo" facility because builtins must execute in the
96: * top-level environment. The original code here permitted a small
97: * subset of builtins to be redirected, but executed them in a
98: * subshell, giving bogus semantics (eg, it permitted "export" to be
99: * redirected, but in a subshell it had no effect).
100: */
101: if (s_func == s_exec)
102: slret = (* s_func) ();
103: else {
104: REDIR_UNDO * undo = NULL;
105:
106: if (redirect (niovp, & undo) < 0)
107: slret = 1;
108: else
109: slret = (* s_func) ();
110:
111: /*
112: * NB: The rationale for the following kludge is not clear,
113: * but with the ability to properly redirect builtins and
114: * execute the in the top-level context, it no longer works.
115: * It could be added back in, but since it conflicts with
116: * POSIX.2 anyway, why bother.
117: */
118: #if 0
119: if (s_func == s_eval)
120: slret = (*s_func)();
121: else {
122: /* Kludge stderr output to stdout. */
123: dup2(1, 2);
124: close(1);
125: slret = (*s_func)();
126: }
127: #endif
128:
129: redirundo (& undo);
130: }
131: return 1;
132: }
133:
134: ihash(cp)
135: register char *cp;
136: {
137: register int i;
138: for (i=0; *cp; i+=*cp++);
139: return i;
140: }
141:
142:
143: /*
144: * Actual builtin functions.
145: */
146: s_colon()
147: {
148: return 0;
149: }
150:
151: s_dot()
152: {
153: if (nargc==2) {
154: ffind(NULL);
155: if (ffind(vpath, nargv[1], 4))
156: return session(SFILE, duplstr(strt, 0));
157: else {
158: ecantfind(nargv[1]);
159: return 1;
160: }
161: } else if (nargc==1)
162: return 0;
163: syntax();
164: return 1;
165: }
166:
167: s_break()
168: {
169: register CON *cp;
170: register int t;
171: register int n;
172: int ret;
173:
174: ret = nargv[0][0]=='b' ? 2 : 1;
175: n = nargc>1 ? atoi(nargv[1]) : 1;
176: for (cp = sesp->s_con; cp; cp = cp->c_next) {
177: t = cp->c_node->n_type;
178: if ((t==NWHILE || t==NFOR || t==NUNTIL) && --n == 0) {
179: sesp->s_con = cp;
180: longjmp(cp->c_envl, ret);
181: break;
182: }
183: freebuf(cp->c_bpp);
184: }
185: printe("%s out of bounds", ret==1 ? "Continue" : "Break");
186: }
187:
188: /* s_continue is overlaid with s_break */
189:
190: s_cd()
191: {
192: register char *dir;
193:
194: if ((dir = cd((nargc<2) ? vhome : nargv[1])) == NULL)
195: return -1; /* cd failed */
196: if (dstack[dstkp] != NULL)
197: sfree(dstack[dstkp]);
198: dstack[dstkp] = duplstr(dir, 1); /* update dir stack */
199: return 0;
200: }
201:
202: s_dirs()
203: {
204: register int i;
205:
206: for (i = dstkp; i >= 0; i--)
207: printf (stdout, "%s ", dstack[i]);
208: fputc('\n', stderr);
209: }
210:
211: s_eval()
212: {
213: if (nargc>1)
214: return session(SARGV, ++nargv);
215: else
216: return 0;
217: }
218:
219: s_exec()
220: {
221: if (redirect (niovp, NULL) < 0) {
222: if (nargc>1) {
223: exit(1);
224: NOTREACHED;
225: }
226: return 1;
227: }
228: if (nargc==1)
229: return 0;
230: if (no1flag) {
231: cleanup_shell_fns ();
232: unlink_temp (capture_temp ());
233: }
234: dflttrp(ICMD);
235: ++nargv;
236: --nargc;
237: nenvp = envlvar(nenvp);
238: flexec();
239: exit(1);
240: NOTREACHED;
241: }
242:
243: s_exit()
244: {
245: if (nargc > 1)
246: slret = atoi(nargv[1]);
247: reset(RUEXITS);
248: NOTREACHED;
249: }
250:
251: s_export()
252: {
253: register int flag;
254: register char **varv;
255:
256: flag = nargv[0][0]=='e' ? VEXP : VRDO;
257: if (nargc < 2)
258: tellvar(flag);
259: else
260: for (varv=++nargv; *varv; )
261: if (namevar(*varv))
262: flagvar(*varv++, flag);
263: else
264: eillvar(*varv++);
265: return 0;
266: }
267:
268: s_login()
269: {
270: register char *cmd;
271:
272: cmd = nargv[0][0]=='l' ? "/bin/login" : "/bin/newgrp";
273: execve(cmd, nargv, envlvar(nenvp));
274: ecantfind(cmd);
275: return 1;
276: }
277:
278: /* s_newgrp is overlaid with s_login */
279:
280: s_popd()
281: {
282: register int i, j, n, ret;
283:
284: if (nargc == 1)
285: return popd();
286: /*
287: * Kludge to pop one or more specific dir stack elements.
288: * Do args backwards so e.g. "popd 2 3 4" works as expected.
289: * Internal indices [0, dstkp] are user indices [dstkp, 0].
290: */
291: for (ret = 0, i = nargc-1; i > 0; i--) {
292: if ((n = atoi(nargv[i])) == 0)
293: ret |= popd();
294: else if (n < 0 || n > dstkp) {
295: printe("Illegal arg: %d", n);
296: ret = -1;
297: continue;
298: } else {
299: j = dstkp - n;
300: if (dstack[j] != NULL)
301: sfree(dstack[j]);
302: for ( ; j < dstkp; j++)
303: dstack[j] = dstack[j+1];
304: --dstkp;
305: }
306: }
307: return ret;
308: }
309:
310: s_pushd()
311: {
312: register char *dir;
313: register int i, ret;
314:
315: if (nargc == 1) {
316: /* Exchange top two stack elements. */
317: if (dstkp == 0)
318: return 1; /* only one element on stack */
319: dir = dstack[dstkp-1];
320: dstack[dstkp-1] = dstack[dstkp];
321: dstack[dstkp] = dir; /* exchange top two */
322: return ((cd(dir) == NULL) ? -1 : 0); /* and cd accordingly */
323: }
324: /* Push one or more directories to stack. */
325: for (ret = 0, i = 1; i < nargc; i++)
326: ret |= pushd(nargv[i]);
327: return ret;
328: }
329:
330: /*
331: * NB: For s_read (), wrap up the temporary-space global bullshit. Later we
332: * can add parameters to this stuff to get the effect of string streams.
333: */
334:
335: #define temp_string_begin() ((void) (strp = strt))
336: #define temp_string_max() STRSIZE
337: #define temp_string_add(c) \
338: (strp < strt + temp_string_max () ? (void) (* strp ++ = c) : \
339: (void) etoolong ())
340: #define temp_string_end() (strt)
341: #define temp_string_end_copy() (duplstr (temp_string_end (), 1))
342: #define temp_string_temp_copy() (duplstr (temp_string_end (), 0))
343: #define temp_mark() (0)
344: #define temp_release(x) ((void) x)
345:
346: typedef int temp_mark_type;
347:
348: #define ARGS(x) x
349: void temp_string_begin ARGS (()) {
350: temp_string_begin ();
351: }
352: int temp_string_max ARGS (()) {
353: return temp_string_max ();
354: }
355: void temp_string_add ARGS ((c)) int c; {
356: temp_string_add (c);
357: }
358: char * temp_string_end ARGS (()) {
359: return temp_string_end ();
360: }
361: char * temp_string_end_copy ARGS (()) {
362: return temp_string_end_copy ();
363: }
364: char * temp_string_temp_copy ARGS (()) {
365: return temp_string_temp_copy ();
366: }
367: temp_mark_type temp_mark ARGS (()) {
368: return temp_mark ();
369: }
370: void temp_release ARGS ((m)) temp_mark_type m; {
371: temp_release (m);
372: }
373:
374: /*
375: * NB: Originally, this code used yylex () to break the input up into words.
376: * This was a bad idea, because this caused the IFS variable to have no
377: * useful effect. Now we just read using <stdio.h> functions, because the
378: * extra machinery for session-management doesn't seem to buy anything.
379: */
380:
381: s_read()
382: {
383: char ** argp = nargv + 1;
384: char ** arg_end = argp + (nargc - 1);
385: char * delimiters;
386: int ch;
387:
388: while (argp < arg_end)
389: if (! namevar (* argp ++))
390: eillvar (argp - 1);
391:
392: delimiters = vifs == NULL ? " \t" : vifs;
393:
394: argp = nargv + 1;
395: while (argp < arg_end) {
396: temp_mark_type mark;
397: enum {
398: EAT_WS,
399: WORD
400: } state = EAT_WS;
401:
402: mark = temp_mark ();
403: temp_string_begin ();
404:
405: if (argp + 1 == arg_end)
406: delimiters = "";
407:
408: while ((ch = getc (stdin)) != EOF && ch != '\n') {
409:
410: if (strchr (delimiters, ch) != NULL) {
411:
412: if (state == EAT_WS)
413: continue;
414: break;
415: }
416:
417: temp_string_add (ch);
418: state = WORD;
419: }
420: temp_string_add (0);
421:
422: assnvar (* argp ++, temp_string_temp_copy ());
423: temp_release (mark);
424:
425: if (ch == EOF || ch == '\n')
426: break;
427: }
428:
429: while (argp < arg_end)
430: assnvar (* argp ++, "");
431:
432: return ch == EOF;
433: }
434:
435:
436: /* s_readonly overlaid with s_export */
437:
438: s_set()
439: {
440: if (nargc < 2) {
441: tellvar(0);
442: return 0;
443: }
444: return set(nargc, nargv, 0);
445: }
446:
447: s_shift()
448: {
449: register int n;
450:
451: n = nargc > 1 ? atoi(nargv[1]) : 1;
452: while (n > 0 && sargc > 0) {
453: n -= 1;
454: sargc -= 1;
455: sargp += 1;
456: }
457: return n!=0;
458: }
459:
460: s_times()
461: {
462: #if _I386
463: #define tb_cutime tms_cutime
464: #define tb_cstime tms_cstime
465: struct tms tb;
466: #else
467: struct tbuffer tb;
468:
469: #endif
470:
471: times(&tb);
472: ptime(tb.tb_cutime);
473: ptime(tb.tb_cstime);
474: puts ("\n");
475: return 0;
476: }
477:
478: s_trap()
479: {
480: register char **vp;
481: register char *cp;
482: register int err;
483:
484: err = 0;
485: if (nargc==1)
486: return telltrp();
487: vp = ++nargv;
488: cp = *vp;
489: if (class(cp[0], MDIGI)
490: && (cp[1]=='\0' || (class(cp[1], MDIGI) && cp[2]=='\0')))
491: cp = NULL;
492: else
493: ++vp;
494: while (*vp) {
495: if (class(vp[0][0], MDIGI))
496: err |= setstrp(atoi(*vp++), cp);
497: else {
498: printe("Bad trap: %s", *vp++);
499: err |= 1;
500: }
501: }
502: return err;
503: }
504:
505: s_umask()
506: {
507: if (nargc < 2)
508: printf ("%03o\n", ufmask);
509: else
510: umask(ufmask = atoi(nargv[1]));
511: return 0;
512: }
513:
514: s_wait()
515: {
516: register int f;
517:
518: f = (nargc > 1) ? atoi(nargv[1]) : 0;
519: if (f > 0)
520: f = -f;
521: waitc(f);
522: return slret;
523: }
524:
525: /*
526: * Change to given directory.
527: * Update global variable CWD accordingly.
528: * Return NULL if bad, otherwise full pathname of the directory.
529: */
530: char *
531: cd(dir) register char *dir;
532: {
533: if (chdir(dir) < 0) {
534: printe("%s: bad directory", dir);
535: return NULL;
536: }
537: if (*dir != '/') {
538: /*
539: * Find an absolute pathname for the dstack and $CWD.
540: * The directory now in dstack[dstkp] is "." if _getwd() failed
541: * for any reason (e.g., the user lacks search permission
542: * down the path to "/", or "." was rm'ed by another process).
543: * Avoid _getwd() in this case, it can undo the chdir() above.
544: */
545: if ((strcmp(dstack[dstkp], ".") == 0)
546: || ((dir = _getwd()) == NULL))
547: return NULL;
548: }
549: assnvar("CWD", dir);
550: return dir;
551: }
552:
553: /*
554: * Pop the directory stack and change to the previous stacked directory.
555: */
556: popd()
557: {
558: if (dstkp == 0) {
559: printe("Directory stack underflow");
560: return -1;
561: }
562: if (dstack[dstkp] != NULL)
563: sfree(dstack[dstkp]);
564: return (cd(dstack[--dstkp]) == NULL ? -1 : 0);
565: }
566:
567: /*
568: * Change to given directory and add it to the directory stack.
569: */
570: pushd(dir) register char *dir;
571: {
572: if ((dir = cd(dir)) == NULL)
573: return -1; /* cd failed */
574: if (++dstkp >= DSTACKN) {
575: --dstkp;
576: printe("Directory stack overflow");
577: return -1;
578: }
579: dstack[dstkp] = duplstr(dir, 1);
580: return 0;
581: }
582:
583: /*
584: * The set command. This is also called from `main' to set
585: * options from the command line. In this case `flag' is
586: * set.
587: */
588: set(argc, argv, flag)
589: register char *argv[];
590: {
591: int n;
592: register char *cp;
593:
594: if (flag) {
595: cflag = 0;
596: iflag = 0;
597: sflag = 0;
598: }
599: n = 0;
600: if (argc > 0)
601: n = 1;
602: if (argc>1 && argv[1][0]=='-') {
603: register char *fp;
604:
605: n++;
606: for (cp = &argv[1][1]; *cp; cp++) {
607: if ((fp=index(shfnams, *cp)) == NULL
608: || (fp+=shflags-shfnams) == NULL
609: || (fp != &lgnflag && fp > &xflag && flag == 0))
610: printe("-%c: Bad option", *cp);
611: else if (fp != &lgnflag)
612: *fp = *cp;
613: }
614: if (cp == &argv[1][1]) {
615: vflag = 0;
616: xflag = 0;
617: }
618: if (flag == 0 && argc == 2)
619: return errflag;
620: }
621: if (errflag)
622: return 1;
623: if (sargv != NULL)
624: vfree(sargv);
625: sargv = vdupl(argv);
626: sargc = argc - n;
627: sargp = sargv + n;
628: return 0;
629: }
630:
631: /*
632: * print the time as XmX.Xs
633: * as fixed by Randall.
634: */
635: ptime(t)
636: long t;
637: {
638: register int ticks, tenths, seconds;
639:
640: printf ("%ldm", t/MINUTE);
641: ticks = t%MINUTE;
642: seconds = ticks/SECOND;
643: tenths = (ticks%SECOND + SECOND/20)/(SECOND/10);
644: if (tenths == 10) {
645: tenths = 0;
646: seconds++;
647: }
648: printf ("%d.%ds ", seconds, tenths);
649: }
650:
651: /* User-defined shell functions. */
652:
653: /*
654: * Lookup a shell function name.
655: * The hashing is probably irrelevant.
656: */
657: SHFUNC *
658: lookup_sh_fn(name) char *name;
659: {
660: register SHFUNC *fnp;
661: register int ahash;
662:
663: ahash = ihash(name);
664: for (fnp=sh_fnp; fnp != NULL; fnp = fnp->fn_link)
665: if (fnp->fn_hash==ahash && strcmp(name, fnp->fn_name)==0)
666: return fnp;
667: return NULL;
668: }
669:
670:
671: /*
672: * When a subshell is created, the functions are available in the subshell
673: * but we don't want to lose the here-documents.
674: */
675:
676: void subshell_shell_fns ()
677: {
678: SHFUNC * scan;
679:
680: scan = sh_fnp;
681:
682: while (scan != NULL) {
683: forget_temp (scan->fn_temp);
684: scan->fn_temp = NULL;
685: scan = scan->fn_link;
686: }
687: }
688:
689:
690: /*
691: * Unset a shell function, freeing the function body and detaching any
692: * temporary files.
693: */
694:
695: void cleanup_shell_fn (fnp)
696: SHFUNC * fnp;
697: {
698: free_node (fnp->fn_body);
699: unlink_temp (fnp->fn_temp);
700: }
701:
702:
703: /*
704: * Before final exit, clean up all shell functions. Freeing the memory of
705: * the function bodies is a waste of time here, so we leave that alone.
706: */
707:
708: void cleanup_shell_fns ()
709: {
710: SHFUNC * scan;
711: SHFUNC * next;
712:
713: for (scan = sh_fnp ; scan != NULL ; scan = next) {
714: next = scan->fn_link;
715: unlink_temp (scan->fn_temp);
716: #if 0
717: cleanup_shell_fn (scan);
718: sfree (scan->fn_name);
719: sfree (scan);
720: #endif
721: }
722:
723: sh_fnp = NULL;
724: }
725:
726:
727: /*
728: * Define a shell function.
729: */
730: def_shell_fn(np) register NODE *np;
731: {
732: register char *name;
733: register SHFUNC *fnp;
734:
735: name = np->n_strp;
736: if ((fnp = lookup_sh_fn(name)) != NULL)
737: cleanup_shell_fn (fnp); /* redeclared, free old body */
738: else {
739: fnp = salloc(sizeof *fnp); /* allocate new function */
740: fnp->fn_link = sh_fnp; /* add it to list */
741: sh_fnp = fnp;
742: fnp->fn_hash = ihash(name); /* and set member info */
743: fnp->fn_name = duplstr(name, 1);
744: }
745: fnp->fn_temp = capture_temp ();
746: fnp->fn_body = copy_node(np->n_next); /* and copy function body */
747: }
748:
749: /*
750: * Look for a shell function, execute it if found.
751: */
752: int
753: sh_fn()
754: {
755: register SHFUNC *fnp;
756: CON *ocon;
757: int oargc;
758: char *oarg0;
759: char **oargv, **oargp;
760:
761: if (nargv[0] == NULL)
762: return 0;
763: if ((fnp = lookup_sh_fn(nargv[0])) == NULL)
764: return 0;
765:
766: /* Set up sargc, sarg0, sargv, sargp here for $1 etc. to work. */
767: oarg0 = sarg0;
768: oargc = sargc;
769: oargv = sargv;
770: oargp = sargp;
771: sarg0 = nargv[0];
772: sargc = nargc - 1;
773: sargp = sargv = vdupl(nargv+1);
774: ocon = sesp->s_con;
775: sesp->s_con = NULL;
776:
777: ++in_sh_fn;
778: slret = command(fnp->fn_body); /* execute it */
779: --in_sh_fn;
780: ret_done = 0;
781: vfree(sargv);
782:
783: sesp->s_con = ocon;
784: sarg0 = oarg0;
785: sargc = oargc;
786: sargv = oargv;
787: sargp = oargp;
788: return 1;
789: }
790:
791: /*
792: * Recursively allocate a fresh copy of a NODE.
793: * Examines type to decide if node uses strp or auxp.
794: * Watch out for nodes which contain loops: NFOR2, NWHILE, NUNTIL.
795: */
796: NODE *
797: copy_node(np) NODE *np;
798: {
799: register NODE *newnp;
800: int flag;
801:
802: #if 0
803: printf("copy_node(%x)", np);
804: if (np != NULL)
805: printf(" type=%d", np->n_type);
806: printf("\n");
807: #endif
808: if (np == NULL)
809: return NULL;
810: flag = 0;
811: newnp = salloc(sizeof *np); /* allocate new NODE */
812: newnp->n_type = np->n_type;
813: switch(np->n_type) {
814:
815: /* The following cases use the strp member. */
816: case NRET:
817: case NFOR:
818: case NARGS:
819: case NASSG:
820: case NCASE:
821: case NCASE3:
822: case NIORS:
823: case NFUNC:
824: newnp->n_strp = duplstr(np->n_strp, 1);
825: break;
826:
827: /* The following cases use the auxp member. */
828: case NWHILE:
829: case NUNTIL:
830: case NFOR2:
831: flag++;
832: np->n_next->n_next = NULL; /* zap the loop for recursion */
833: /* fall through... */
834: case NNULL:
835: case NCOMS:
836: case NCTRL:
837: case NBRAC:
838: case NPARN:
839: case NIF:
840: case NELSE:
841: case NCASE2:
842: case NLIST:
843: case NANDF:
844: case NORF:
845: case NBACK:
846: case NPIPE:
847: newnp->n_auxp = copy_node(np->n_auxp);
848: break;
849:
850: case NRPIPE:
851: case NWPIPE:
852: default:
853: /* ??? */
854: printf("type=%d\n", np->n_type);
855: panic(9);
856: }
857: newnp->n_next = copy_node(np->n_next);
858: if (flag)
859: newnp->n_next->n_next = newnp; /* restore loop */
860: return newnp;
861: }
862:
863: /*
864: * Undo the above.
865: */
866: free_node(np) register NODE *np;
867: {
868: if (np == NULL)
869: return;
870: switch(np->n_type) {
871:
872: /* strp */
873: case NRET:
874: case NFOR:
875: case NARGS:
876: case NASSG:
877: case NCASE:
878: case NCASE3:
879: case NIORS:
880: case NFUNC:
881: sfree(np->n_strp);
882: break;
883:
884: /* auxp */
885: case NWHILE:
886: case NUNTIL:
887: case NFOR2:
888: np->n_next->n_next = NULL; /* zap the loop for recursion */
889: /* fall through... */
890: case NNULL:
891: case NCOMS:
892: case NCTRL:
893: case NBRAC:
894: case NPARN:
895: case NIF:
896: case NELSE:
897: case NCASE2:
898: case NLIST:
899: case NANDF:
900: case NORF:
901: case NBACK:
902: case NPIPE:
903: free_node(np->n_auxp);
904: break;
905:
906: case NRPIPE:
907: case NWPIPE:
908: default:
909: /* ??? */
910: printf("type=%d\n", np->n_type);
911: panic(10);
912: }
913: free_node(np->n_next);
914: sfree(np);
915: }
916:
917: /* end of sh/exec3.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.