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