![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sh|
Return to cmd.c CVS log | Up to [Research Unix] / researchv9 / cmd / sh |
1.1 root 1: /* @(#)cmd.c 1.5 */
2: /*
3: * UNIX shell
4: *
5: * Bell Telephone Laboratories
6: *
7: */
8:
9: #include "defs.h"
10: #include "sym.h"
11:
12: static struct ionod * inout();
13: static int chkword();
14: static int chksym();
15: static struct trenod * term();
16: static struct trenod * makelist();
17: static struct trenod * list();
18: static struct regnod * syncase();
19: static struct trenod * item();
20: static int skipnl();
21: static int prsym();
22: static int synbad();
23:
24:
25: /* ======== storage allocation for functions ======== */
26:
27: char *
28: getstor(asize)
29: int asize;
30: {
31: if (fndef)
32: return(shalloc(asize));
33: else
34: return(getstak(asize));
35: }
36:
37:
38: /* ======== command line decoding ========*/
39:
40:
41:
42:
43: struct trenod *
44: makefork(flgs, i)
45: int flgs;
46: struct trenod *i;
47: {
48: register struct forknod *t;
49:
50: t = (struct forknod *)getstor(sizeof(struct forknod));
51: t->forktyp = flgs|TFORK;
52: t->forktre = i;
53: t->forkio = 0;
54: return((struct trenod *)t);
55: }
56:
57: static struct trenod *
58: makelist(type, i, r)
59: int type;
60: struct trenod *i, *r;
61: {
62: register struct lstnod *t;
63:
64: if (i == 0 || r == 0)
65: synbad();
66: else
67: {
68: t = (struct lstnod *)getstor(sizeof(struct lstnod));
69: t->lsttyp = type;
70: t->lstlef = i;
71: t->lstrit = r;
72: }
73: return((struct trenod *)t);
74: }
75:
76: /*
77: * cmd
78: * empty
79: * list
80: * list & [ cmd ]
81: * list [ ; cmd ]
82: */
83: struct trenod *
84: cmd(sym, flg)
85: register int sym;
86: int flg;
87: {
88: register struct trenod *i, *e;
89:
90: i = list(flg);
91: if (wdval == NL)
92: {
93: if (flg & NLFLG)
94: {
95: wdval = ';';
96: chkpr();
97: }
98: }
99: else if (i == 0 && (flg & MTFLG) == 0)
100: synbad();
101:
102: switch (wdval)
103: {
104: case '&':
105: if (i)
106: i = makefork(FINT | FPRS | FAMP, i);
107: else
108: synbad();
109:
110: case ';':
111: if (e = cmd(sym, flg | MTFLG))
112: i = makelist(TLST, i, e);
113: else if (i==0 && (flg & MTFLG) == 0)
114: synbad();
115: break;
116:
117: case EOFSYM:
118: if (sym == NL)
119: break;
120:
121: default:
122: if (sym)
123: chksym(sym);
124: }
125: return(i);
126: }
127:
128: /*
129: * list
130: * term
131: * list && term
132: * list || term
133: */
134: static struct trenod *
135: list(flg)
136: {
137: register struct trenod *r;
138: register int b;
139:
140: r = term(flg);
141: while (r && ((b = (wdval == ANDFSYM)) || wdval == ORFSYM))
142: r = makelist((b ? TAND : TORF), r, term(NLFLG));
143: return(r);
144: }
145:
146: /*
147: * term
148: * item
149: * item | term
150: */
151: static struct trenod *
152: term(flg)
153: {
154: register struct trenod *t;
155:
156: reserv++;
157: if (flg & NLFLG)
158: skipnl();
159: else
160: word();
161: if ((t = item(TRUE)) && wdval == '|')
162: {
163: struct trenod *left;
164: struct trenod *right;
165:
166: left = makefork(FPOU, t);
167: right = makefork(FPIN | FPCL, term(NLFLG));
168: return(makefork(0, makelist(TFIL, left, right)));
169: }
170: else
171: return(t);
172: }
173:
174: static struct regnod *
175: syncase(esym)
176: register int esym;
177: {
178: skipnl();
179: if (wdval == esym)
180: return(0);
181: else
182: {
183: register struct regnod *r = (struct regnod *)getstor(sizeof(struct regnod));
184: register struct argnod *argp;
185:
186: r->regptr = 0;
187: for (;;)
188: {
189: if (fndef)
190: {
191: argp= wdarg;
192: wdarg = (struct argnod *)shalloc(length(argp->argval) + BYTESPERWORD);
193: movstr(argp->argval, wdarg->argval);
194: }
195:
196: wdarg->argnxt = r->regptr;
197: r->regptr = wdarg;
198: if (wdval || (word() != ')' && wdval != '|'))
199: synbad();
200: if (wdval == '|')
201: word();
202: else
203: break;
204: }
205: r->regcom = cmd(0, NLFLG | MTFLG);
206: if (wdval == ECSYM)
207: r->regnxt = syncase(esym);
208: else
209: {
210: chksym(esym);
211: r->regnxt = 0;
212: }
213: return(r);
214: }
215: }
216:
217: /*
218: * item
219: *
220: * ( cmd ) [ < in ] [ > out ]
221: * word word* [ < in ] [ > out ]
222: * if ... then ... else ... fi
223: * for ... while ... do ... done
224: * case ... in ... esac
225: * begin ... end
226: */
227: static struct trenod *
228: item(flag)
229: BOOL flag;
230: {
231: register struct trenod *r;
232: register struct ionod *io;
233:
234: if (flag)
235: io = inout((struct ionod *)0);
236: else
237: io = 0;
238: switch (wdval)
239: {
240: case CASYM:
241: {
242: register struct swnod *t;
243:
244: t = (struct swnod *)getstor(sizeof(struct swnod));
245: r = (struct trenod *)t;
246:
247: chkword();
248: if (fndef)
249: t->swarg = make(wdarg->argval);
250: else
251: t->swarg = wdarg->argval;
252: skipnl();
253: chksym(INSYM);
254: t->swlst = syncase(ESSYM);
255: t->swtyp = TSW;
256: break;
257: }
258:
259: case IFSYM:
260: {
261: register int w;
262: register struct ifnod *t;
263:
264: t = (struct ifnod *)getstor(sizeof(struct ifnod));
265: r = (struct trenod *)t;
266:
267: t->iftyp = TIF;
268: t->iftre = cmd(THSYM, NLFLG);
269: t->thtre = cmd(ELSYM | FISYM | EFSYM, NLFLG);
270: t->eltre = ((w = wdval) == ELSYM ? cmd(FISYM, NLFLG) : (w == EFSYM ? (wdval = IFSYM, item(0)) : 0));
271: if (w == EFSYM)
272: return(r);
273: break;
274: }
275:
276: case FORSYM:
277: {
278: register struct fornod *t;
279:
280: t = (struct fornod *)getstor(sizeof(struct fornod));
281: r = (struct trenod *)t;
282:
283: t->fortyp = TFOR;
284: t->forlst = 0;
285: chkword();
286: if (fndef)
287: t->fornam = make(wdarg->argval);
288: else
289: t->fornam = wdarg->argval;
290: if (skipnl() == INSYM)
291: {
292: chkword();
293:
294: t->forlst = (struct comnod *)item(0);
295:
296: if (wdval != NL && wdval != ';')
297: synbad();
298: if (wdval == NL)
299: chkpr();
300: skipnl();
301: }
302: else if (wdval == ';')
303: reserv++, word(); /* eat the ';' */
304: chksym(DOSYM);
305: t->fortre = cmd(ODSYM, NLFLG);
306: break;
307: }
308:
309: case WHSYM:
310: case UNSYM:
311: {
312: register struct whnod *t;
313:
314: t = (struct whnod *)getstor(sizeof(struct whnod));
315: r = (struct trenod *)t;
316:
317: t->whtyp = (wdval == WHSYM ? TWH : TUN);
318: t->whtre = cmd(DOSYM, NLFLG);
319: t->dotre = cmd(ODSYM, NLFLG);
320: break;
321: }
322:
323: case '{':
324: r = cmd('}', NLFLG);
325: break;
326:
327: case '(':
328: {
329: register struct parnod *p;
330:
331: p = (struct parnod *)getstor(sizeof(struct parnod));
332: p->partre = cmd(')', NLFLG);
333: p->partyp = TPAR;
334: r = makefork(0, p);
335: break;
336: }
337:
338: default:
339: if (io == 0)
340: return(0);
341:
342: case 0:
343: {
344: register struct comnod *t;
345: register struct argnod *argp;
346: register struct argnod **argtail;
347: register struct argnod **argset = 0;
348: int keywd = 1;
349: char *com;
350:
351: if ((wdval != NL) && ((peekn = skipc()) == '('))
352: {
353: struct fndnod *f;
354: struct ionod *saveio;
355:
356: saveio = iotemp;
357: peekn = 0;
358: if (skipc() != ')')
359: synbad();
360:
361: f = (struct fndnod *)getstor(sizeof(struct fndnod));
362: r = (struct trenod *)f;
363:
364: f->fndtyp = TFND;
365: if (fndef)
366: f->fndnam = make(wdarg->argval);
367: else
368: f->fndnam = wdarg->argval;
369: reserv++;
370: fndef++;
371: skipnl();
372: f->fndval = (struct trenod *)item(TRUE);
373: fndef--;
374:
375: if (iotemp != saveio)
376: {
377: struct ionod *ioptr = iotemp;
378:
379: while (ioptr->iolst != saveio)
380: ioptr = ioptr->iolst;
381:
382: ioptr->iolst = fiotemp;
383: fiotemp = iotemp;
384: iotemp = saveio;
385: }
386: return(r);
387: }
388: else
389: {
390: t = (struct comnod *)getstor(sizeof(struct comnod));
391: r = (struct trenod *)t;
392:
393: t->comio = io; /*initial io chain*/
394: argtail = &(t->comarg);
395:
396: while (wdval == 0)
397: {
398: if (fndef)
399: {
400: argp = wdarg;
401: wdarg = (struct argnod *)shalloc(length(argp->argval) + BYTESPERWORD);
402: movstr(argp->argval, wdarg->argval);
403: }
404:
405: argp = wdarg;
406: if (wdset && keywd)
407: {
408: argp->argnxt = (struct argnod *)argset;
409: argset = (struct argnod **)argp;
410: }
411: else
412: {
413: *argtail = argp;
414: argtail = &(argp->argnxt);
415: keywd = flags & keyflg;
416: }
417: word();
418: if (flag)
419: t->comio = inout(t->comio);
420: }
421:
422: t->comtyp = TCOM;
423: t->comset = (struct argnod *)argset;
424: *argtail = 0;
425:
426: return(r);
427: }
428: }
429:
430: }
431: reserv++;
432: word();
433: if (io = inout(io))
434: {
435: r = makefork(0,r);
436: r->treio = io;
437: }
438: return(r);
439: }
440:
441:
442: static int
443: skipnl()
444: {
445: while ((reserv++, word() == NL))
446: chkpr();
447: return(wdval);
448: }
449:
450: static struct ionod *
451: inout(lastio)
452: struct ionod *lastio;
453: {
454: register int iof;
455: register struct ionod *iop;
456: register char c;
457:
458: iof = wdnum;
459: switch (wdval)
460: {
461: case DOCSYM: /* << */
462: iof |= IODOC;
463: break;
464:
465: case APPSYM: /* >> */
466: case '>':
467: if (wdnum == 0)
468: iof |= 1;
469: iof |= IOPUT;
470: if (wdval == APPSYM)
471: {
472: iof |= IOAPP;
473: break;
474: }
475:
476: case '<':
477: if ((c = nextc(0)) == '&')
478: iof |= IOMOV;
479: else if (c == '>')
480: iof |= IORDW;
481: else
482: peekc = c | MARK;
483: break;
484:
485: default:
486: return(lastio);
487: }
488:
489: chkword();
490: iop = (struct ionod *)getstor(sizeof(struct ionod));
491:
492: if (fndef)
493: iop->ioname = make(wdarg->argval);
494: else
495: iop->ioname = wdarg->argval;
496:
497: iop->iolink = 0;
498: iop->iofile = iof;
499: if (iof & IODOC)
500: {
501: iop->iolst = iopend;
502: iopend = iop;
503: }
504: word();
505: iop->ionxt = inout(lastio);
506: return(iop);
507: }
508:
509: static int
510: chkword()
511: {
512: if (word())
513: synbad();
514: }
515:
516: static int
517: chksym(sym)
518: {
519: register int x = sym & wdval;
520:
521: if (((x & SYMFLG) ? x : sym) != wdval)
522: synbad();
523: }
524:
525: static int
526: prsym(sym)
527: {
528: if (sym & SYMFLG)
529: {
530: register struct sysnod *sp = reserved;
531:
532: while (sp->sysval && sp->sysval != sym)
533: sp++;
534: prs(sp->sysnam);
535: }
536: else if (sym == EOFSYM)
537: prs(endoffile);
538: else
539: {
540: if (sym & SYMREP)
541: prc(sym);
542: if (sym == NL)
543: prs("newline or ;");
544: else
545: prc(sym);
546: }
547: }
548:
549: static int
550: synbad()
551: {
552: prp();
553: prs(synmsg);
554: if ((flags & ttyflg) == 0)
555: {
556: prs(atline);
557: prn(standin->flin);
558: }
559: prs(colon);
560: prc(LQ);
561: if (wdval)
562: prsym(wdval);
563: else
564: prs_cntl(wdarg->argval);
565: prc(RQ);
566: prs(unexpected);
567: newline();
568: exitsh(SYNBAD);
569: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.