![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c_sh.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / a / usr / bob / korn|
Return to c_sh.c CVS log | Up to [MW Coherent from dump] / coherent / a / usr / bob / korn |
1.1 root 1: /*
2: * built-in Bourne commands
3: */
4:
5: static char *RCSid = "$Header: c_sh.c,v 3.1 88/11/03 09:14:31 egisin Exp $";
6:
7: #include <stddef.h>
8: #include <stdlib.h>
9: #include <stdio.h>
10: #include <string.h>
11: #include <errno.h>
12: #include <signal.h>
13: #include <setjmp.h>
14: #include <sys/times.h>
15: #include <unistd.h> /* getcwd */
16: #include "sh.h"
17: #include "lex.h"
18: #include "tree.h"
19: #include "table.h"
20:
21: static void putvlist();
22: static char *clocktos();
23:
24: int
25: c_label(wp)
26: char **wp;
27: {
28: return 0;
29: }
30:
31: /* todo: add symlink hacks */
32: int
33: c_cd(wp)
34: register char **wp;
35: {
36: static char path[PATH];
37: register char *cp;
38: register struct tbl *vp;
39:
40: if ((cp = wp[1]) == NULL && (cp = strval(global("HOME"))) == NULL)
41: errorf("no home directory");
42: if (strcmp(cp, "-") == 0) {
43: cp = strval(global("OLDPWD"));
44: shellf("%s\n", cp);
45: }
46: if (chdir(cp) < 0)
47: errorf("%s: bad directory\n", cp);
48: flushcom(0);
49:
50: /* maintain $PWD and $OLDPWD */
51: vp = global("PWD");
52: cp = strval(vp);
53: if (cp != null)
54: setstr(global("OLDPWD"), cp);
55: cp = getcwd(path, (size_t)PATH);
56: if (cp == NULL)
57: unset(vp);
58: else
59: setstr(vp, cp);
60:
61: return 0;
62: }
63:
64: int
65: c_shift(wp)
66: register char **wp;
67: {
68: register struct block *l = e.loc;
69: register int n;
70:
71: n = wp[1] ? evaluate(wp[1]) : 1;
72: if (l->argc < n) {
73: errorf("nothing to shift\n");
74: return (1);
75: }
76: l->argv[n] = l->argv[0];
77: l->argv += n;
78: l->argc -= n;
79: return 0;
80: }
81:
82: int
83: c_umask(wp)
84: register char **wp;
85: {
86: register int i;
87: register char *cp;
88:
89: if ((cp = wp[1]) == NULL) {
90: i = umask(0);
91: umask(i);
92: printf("%03o\n", i); /* should this be shell output? */
93: } else {
94: for (i = 0; *cp>='0' && *cp<='7'; cp++)
95: i = i*8 + (*cp-'0');
96: umask(i);
97: }
98: return 0;
99: }
100:
101: int
102: c_dot(wp)
103: char **wp;
104: {
105: char *file, *cp;
106:
107: if ((cp = wp[1]) == NULL)
108: return 0;
109: file = search(cp, path, 0);
110: if (file == NULL)
111: errorf("%s: not found\n", cp);
112: if (include(file))
113: return exstat;
114: return -1;
115: }
116:
117: int
118: c_wait(wp)
119: char **wp;
120: {
121: register char *cp;
122:
123: wp++;
124: cp = *wp;
125: if (cp == NULL)
126: cp = "%";
127: /* todo: print status ? */
128: return waitfor(j_lookup(cp));
129: }
130:
131: int
132: c_read(wp)
133: register char **wp;
134: {
135: register int c = 0;
136: FILE *f = stdin;
137: int expand = 1;
138: register char *cp;
139:
140: for (wp++; (cp = *wp) != NULL && *cp++ == '-'; wp++) {
141: while (*cp) switch (*cp++) {
142: case 'e':
143: expand = 1;
144: break;
145: case 'r':
146: expand = 0;
147: break;
148: case 'u':
149: if (!digit(*cp) || (f = shf[*cp++-'0']) == NULL)
150: errorf("bad -u argument\n");
151: break;
152: }
153: }
154:
155: if (*wp == NULL)
156: errorf("missing name\n");
157: if ((cp = strchr(*wp, '?')) != NULL) {
158: *cp = 0;
159: if (flag[FTALKING]) {
160: shellf("%s ", cp+1);
161: fflush(shlout);
162: }
163: }
164:
165: for (; *wp != NULL; wp++) {
166: for (cp = line; cp <= line+LINE; ) {
167: if (c == '\n')
168: break;
169: c = getc(f);
170: if (c == EOF)
171: return 1;
172: if (expand && c == '\\') {
173: c = getc(f);
174: if (c == '\n')
175: c = 0;
176: else
177: *cp++ = c;
178: continue;
179: }
180: if (c == '\n' || wp[1] && ctype(c, C_IFS))
181: break;
182: *cp++ = c;
183: }
184: *cp = 0;
185: setstr(global(*wp), line);
186: }
187: return 0;
188: }
189:
190: int
191: c_eval(wp)
192: register char **wp;
193: {
194: register struct source *s;
195:
196: s = pushs(SWORDS);
197: s->u.strv = wp+1;
198: return shell(s);
199: }
200:
201: void setsig ARGS((struct trap *p, handler_t f));
202:
203: int
204: c_trap(wp)
205: register char **wp;
206: {
207: int i;
208: char *s;
209: register struct trap *p;
210:
211: wp++;
212: if (*wp == NULL) {
213: for (p = sigtraps, i = SIGNALS; --i >= 0; p++) {
214: if (p->trap != NULL)
215: shellf("%s: %s\n", p->name, p->trap);
216: }
217: return 0;
218: }
219:
220: s = (gettrap(*wp) == NULL) ? *wp++ : NULL; /* get command */
221: if (s != NULL && s[0] == '-' && s[1] == '\0')
222: s = NULL;
223:
224: /* set/clear traps */
225: while (*wp != NULL) {
226: p = gettrap(*wp++);
227: if (p == NULL)
228: errorf("trap: bad signal %s\n", wp[-1]);
229: if (p->trap != NULL)
230: afree((Void*)p->trap, APERM);
231: p->trap = NULL;
232: if (s != NULL) {
233: if (strlen(s) != 0) {
234: p->trap = strsave(s, APERM);
235: setsig(p, trapsig);
236: } else
237: setsig(p, (handler_t)SIG_IGN);
238: } else
239: /* todo: restore to orginal value */
240: setsig(p,
241: (p->signal==SIGINT || p->signal==SIGQUIT) && flag[FTALKING]
242: ? (handler_t)SIG_IGN : (handler_t)SIG_DFL);
243: }
244: return 0;
245: }
246:
247: void
248: setsig(p, f)
249: register struct trap *p;
250: void (*f)();
251: {
252: if (p->signal == 0)
253: return;
254: if (signal(p->signal, SIG_IGN) != SIG_IGN || p->ourtrap) {
255: p->ourtrap = 1;
256: signal(p->signal, f);
257: }
258: }
259:
260: int
261: c_return(wp)
262: char **wp;
263: {
264: wp++;
265: if (*wp != NULL)
266: exstat = getn(*wp);
267: quitenv(); /* pop E_TCOM */
268: while (e.type == E_LOOP || e.type == E_EXEC)
269: quitenv();
270: if (e.type == E_FUNC)
271: longjmp(e.jbuf, 1);
272: leave(exstat);
273: }
274:
275: int
276: c_brkcont(wp)
277: register char **wp;
278: {
279: int quit;
280:
281: quit = wp[1] == NULL ? 1 : getn(wp[1]);
282: quitenv(); /* pop E_TCOM */
283: while (e.type == E_LOOP || e.type == E_EXEC) {
284: if (e.type == E_LOOP && --quit <= 0)
285: longjmp(e.jbuf, (*wp[0] == 'b') ? LBREAK : LCONTIN);
286: quitenv();
287: }
288: errorf("cannot %s\n", wp[0]);
289: }
290:
291: int
292: c_exit(wp)
293: char **wp;
294: {
295: register char *cp;
296:
297: e.oenv = NULL;
298: if ((cp = wp[1]) != NULL)
299: exstat = getn(cp);
300: #if JOBS
301: if (flag[FMONITOR] && j_stopped()) /* todo: only once */
302: errorf("There are stopped jobs\n");
303: #endif
304: leave(exstat);
305: }
306:
307: int
308: c_exro(wp)
309: register char **wp;
310: {
311: int flag = (**wp == 'e') ? EXPORT : RDONLY;
312:
313: if (*++wp != NULL) {
314: for (; *wp != NULL; wp++)
315: if (typeset(*wp, flag, 0) == NULL)
316: errorf("%s: bad identifier\n", *wp);
317: } else
318: putvlist(flag);
319: return 0;
320: }
321:
322: static void
323: putvlist(flag)
324: register int flag;
325: {
326: struct block *l = e.loc;
327: register struct tbl *vp, **p;
328:
329: flag |= ISSET;
330: for (l = e.loc; l != NULL; l = l->next)
331: for (p = tsort(&l->vars); (vp = *p++) != NULL; )
332: if ((vp->flag&flag) == flag) {
333: if (vp->flag & EXPORT)
334: printf("export ");
335: if (vp->flag & RDONLY)
336: printf("readonly ");
337: printf("%s\n", vp->name);
338: }
339: }
340:
341: int
342: c_set(wp)
343: register char **wp;
344: {
345: struct block *l = e.loc;
346: register struct tbl *vp, **p;
347: register char **owp = wp;
348: register char *cp;
349: int old_fmonitor = flag[FMONITOR];
350:
351: if ((cp = *++wp) == NULL) {
352: static char * Const args [] = {"set", "-", NULL};
353: extern int c_typeset ARGS((char **args));
354: return c_typeset(args);
355: }
356:
357: for (; (cp = *wp) != NULL && (*cp == '-' || *cp == '+');) {
358: int i, n = *cp++ == '-'; /* set or clear flag */
359: wp++;
360: if (*cp == '\0') {
361: if (n)
362: flag[FXTRACE] = flag[FVERBOSE] = 0;
363: break;
364: }
365: if (*cp == '-')
366: goto setargs;
367: for (; *cp != '\0'; cp++)
368: if (*cp == 'o') {
369: if (*wp == NULL) {
370: printoptions();
371: return 0;
372: }
373: i = option(*wp++);
374: if (i == 0)
375: shellf("%s: unknown option\n", *--wp);
376: flag[i] = n;
377: } else if (*cp>='a' && *cp<='z')
378: flag[FLAG(*cp)] = n;
379: else
380: errorf("%c: bad flag\n", *cp);
381: if (flag[FTALKING])
382: flag[FERREXIT] = 0;
383: }
384:
385: #if JOBS
386: if (old_fmonitor != flag[FMONITOR])
387: j_change();
388: #endif
389:
390: /* set $# and $* */
391: if (*wp != NULL) {
392: setargs:
393: owp = --wp;
394: wp[0] = l->argv[0]; /* save $0 */
395: while (*++wp != NULL)
396: *wp = strsave(*wp, &l->area);
397: l->argc = wp - owp - 1;
398: l->argv = (char **) alloc(sizeofN(char *, l->argc+2), &l->area);
399: for (wp = l->argv; (*wp++ = *owp++) != NULL; )
400: ;
401: resetopts();
402: }
403: return 0;
404: }
405:
406: int
407: c_unset(wp)
408: register char **wp;
409: {
410: register char *id;
411: int flagf = 0;
412:
413: for (wp++; (id = *wp) != NULL && *id == '-'; wp++)
414: if (*++id == 'f')
415: flagf++;
416: for (; (id = *wp) != NULL; wp++)
417: if (!flagf) { /* unset variable */
418: unset(local(id));
419: } else { /* unset function */
420: register struct tbl *tp;
421: tp = tsearch(&e.loc->funs, id, hash(id));
422: if (tp != NULL)
423: define(tp, (struct op *)NULL);
424: }
425: return 0;
426: }
427:
428: int
429: c_ulimit(wp)
430: register char **wp;
431: {
432: extern int do_ulimit();
433:
434: return do_ulimit(wp[1], wp[2]);
435: }
436:
437: int
438: c_times(wp)
439: char **wp;
440: {
441: struct tms all;
442:
443: (void) times(&all);
444: printf("Shell: ");
445: printf("%8s user ", clocktos(all.tms_utime));
446: printf("%8s system\n", clocktos(all.tms_stime));
447: printf("Kids: ");
448: printf("%8s user ", clocktos(all.tms_cutime));
449: printf("%8s system\n", clocktos(all.tms_cstime));
450:
451: return 0;
452: }
453:
454: /*
455: * time pipeline (really a statement, not a built-in comman)
456: */
457: int
458: timex(t, f)
459: struct op *t;
460: int f;
461: {
462: int rv;
463: struct tms t0, t1;
464: clock_t t0t, t1t, time();
465: extern clock_t j_utime, j_stime; /* computed by j_wait */
466:
467: j_utime = j_stime = 0;
468: #if COHERENT
469: t0t = time((clock_t)NULL);
470: (void)times(&t0);
471: #else
472: t0t = times(&t0);
473: #endif
474: rv = execute(t->left, f);
475: #if COHERENT
476: t1t = time((clock_t)NULL);
477: (void)times(&t1);
478: #else
479: t1t = times(&t1);
480: #endif
481: shellf("%8s real ", clocktos((t1t - t0t) * 100));
482: shellf("%8s user ",
483: clocktos(t1.tms_utime - t0.tms_utime + j_utime));
484: shellf("%8s system ",
485: clocktos(t1.tms_stime - t0.tms_stime + j_stime));
486: shellf("\n");
487:
488: return rv;
489: }
490:
491: static char *
492: clocktos(t)
493: clock_t t;
494: {
495: static char temp[20];
496: register int i;
497: register char *cp = temp + sizeof(temp);
498:
499: #if !COHERENT
500: #if CLK_TCK != 100 /* convert to 1/100'ths */
501: t = (t < 1000000000/CLK_TCK) ?
502: (t * 100) / CLK_TCK : (t / CLK_TCK) * 100;
503: #endif
504: #endif
505: *--cp = '\0';
506: *--cp = 's';
507: for (i = -2; i <= 0 || t > 0; i++) {
508: if (i == 0)
509: *--cp = '.';
510: *--cp = '0' + (char)(t%10);
511: t /= 10;
512: }
513: return cp;
514: }
515:
516: /* dummy function, special case in comexec() */
517: int
518: c_exec(wp)
519: char ** wp;
520: {
521: return 0;
522: }
523:
524: /* dummy function, special case in comexec() */
525: int
526: c_builtin(wp)
527: char ** wp;
528: {
529: return 0;
530: }
531:
532: extern int c_test(); /* in test.c */
533:
534: Const struct builtin shbuiltins [] = {
535: {"=:", c_label},
536: {"=.", c_dot},
537: {"[", c_test},
538: {"=cd", c_cd},
539: {"builtin", c_builtin},
540: {"=exec", c_exec},
541: {"=shift", c_shift},
542: {"wait", c_wait},
543: {"read", c_read},
544: {"=eval", c_eval},
545: {"trap", c_trap},
546: {"break", c_brkcont},
547: {"continue", c_brkcont},
548: {"exit", c_exit},
549: {"=export", c_exro},
550: {"=readonly", c_exro},
551: {"=return", c_return},
552: {"=set", c_set},
553: {"=unset", c_unset},
554: {"umask", c_umask},
555: {"test", c_test},
556: {"times", c_times},
557: {"ulimit", c_ulimit},
558: {NULL, NULL}
559: };
560:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.