![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to func.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 func.c CVS log | Up to [Research Unix] / researchv9 / cmd / sh |
1.1 root 1: /* @(#)func.c 1.2 */
2: /*
3: * UNIX shell
4: *
5: * Bell Telephone Laboratories
6: *
7: */
8:
9: #include "defs.h"
10:
11: #define prfc(c) pushstak(c)
12:
13: freefunc(val)
14: char *val;
15: {
16: freetree((struct trenod *)val);
17: }
18:
19:
20: freetree(t)
21: register struct trenod *t;
22: {
23: if (t)
24: {
25: register int type;
26:
27: if (t->tretyp & CNTMSK)
28: {
29: t->tretyp--;
30: return;
31: }
32:
33: type = t->tretyp & COMMSK;
34:
35: switch (type)
36: {
37: case TFND:
38: shfree(fndptr(t)->fndnam);
39: freetree(fndptr(t)->fndval);
40: break;
41:
42: case TCOM:
43: freeio(comptr(t)->comio);
44: free_arg(comptr(t)->comarg);
45: free_arg(comptr(t)->comset);
46: break;
47:
48: case TFORK:
49: freeio(forkptr(t)->forkio);
50: freetree(forkptr(t)->forktre);
51: break;
52:
53: case TPAR:
54: freetree(parptr(t)->partre);
55: break;
56:
57: case TFIL:
58: case TLST:
59: case TAND:
60: case TORF:
61: freetree(lstptr(t)->lstlef);
62: freetree(lstptr(t)->lstrit);
63: break;
64:
65: case TFOR:
66: {
67: struct fornod *f = (struct fornod *)t;
68:
69: shfree(f->fornam);
70: freetree(f->fortre);
71: if (f->forlst)
72: {
73: freeio(f->forlst->comio);
74: free_arg(f->forlst->comarg);
75: free_arg(f->forlst->comset);
76: shfree(f->forlst);
77: }
78: }
79: break;
80:
81: case TWH:
82: case TUN:
83: freetree(whptr(t)->whtre);
84: freetree(whptr(t)->dotre);
85: break;
86:
87: case TIF:
88: freetree(ifptr(t)->iftre);
89: freetree(ifptr(t)->thtre);
90: freetree(ifptr(t)->eltre);
91: break;
92:
93: case TSW:
94: shfree(swptr(t)->swarg);
95: freereg(swptr(t)->swlst);
96: break;
97: }
98: shfree(t);
99: }
100: }
101:
102: free_arg(argp)
103: register struct argnod *argp;
104: {
105: register struct argnod *sav;
106:
107: while (argp)
108: {
109: sav = argp->argnxt;
110: shfree(argp);
111: argp = sav;
112: }
113: }
114:
115:
116: freeio(iop)
117: register struct ionod *iop;
118: {
119: register struct ionod *sav;
120:
121: while (iop)
122: {
123: if ((iop->iofile & IODOC) && fiotemp != 0)
124: {
125:
126: #ifdef DEBUG
127: prs("unlinking ");
128: prs(iop->ioname);
129: newline();
130: #endif
131:
132: unlink(iop->ioname);
133:
134: if (fiotemp == iop)
135: fiotemp = iop->iolst;
136: else
137: {
138: struct ionod *fiop = fiotemp;
139:
140: while (fiop->iolst != iop)
141: fiop = fiop->iolst;
142:
143: fiop->iolst = iop->iolst;
144: }
145: }
146: shfree(iop->ioname);
147: shfree(iop->iolink);
148: sav = iop->ionxt;
149: shfree(iop);
150: iop = sav;
151: }
152: }
153:
154:
155: freereg(regp)
156: register struct regnod *regp;
157: {
158: register struct regnod *sav;
159:
160: while (regp)
161: {
162: free_arg(regp->regptr);
163: freetree(regp->regcom);
164: sav = regp->regnxt;
165: shfree(regp);
166: regp = sav;
167: }
168: }
169: /*
170: * Leaves string on top of stack
171: */
172: char *
173: strf(n)
174: register struct namnod *n;
175: {
176: char *s = locstak();
177: prfstr(n->namid);
178: prfstr("(){\n");
179: prf(n->namval.val);
180: prfstr("\n}");
181: prfc('\0');
182: return staktop=s;
183: }
184: prfstr(s)
185: register char *s;
186: {
187: while(*s)
188: prfc(*s++);
189: }
190: prf(t)
191: register struct trenod *t;
192: {
193: sigchk();
194:
195: if (t)
196: {
197: register int type;
198:
199: type = t->tretyp & COMMSK;
200:
201: switch(type)
202: {
203: case TFND:
204: {
205: register struct fndnod *f = (struct fndnod *)t;
206:
207: prfstr(f->fndnam);
208: prfstr("(){\n");
209: prf(f->fndval);
210: prfstr("\n}");
211: break;
212: }
213:
214: case TCOM:
215: {
216: prarg(comptr(t)->comset);
217: prarg(comptr(t)->comarg);
218: prio(comptr(t)->comio);
219: break;
220: }
221:
222: case TFORK:
223: prf(forkptr(t)->forktre);
224: prio(forkptr(t)->forkio);
225: if (forkptr(t)->forktyp & FAMP)
226: prfstr(" &");
227: break;
228:
229: case TPAR:
230: prfstr("(");
231: prf(parptr(t)->partre);
232: prfstr(")");
233: break;
234:
235: case TFIL:
236: prf(lstptr(t)->lstlef);
237: prfstr(" | ");
238: prf(lstptr(t)->lstrit);
239: break;
240:
241: case TLST:
242: prf(lstptr(t)->lstlef);
243: prfc(NL);
244: prf(lstptr(t)->lstrit);
245: break;
246:
247: case TAND:
248: prf(lstptr(t)->lstlef);
249: prfstr(" && ");
250: prf(lstptr(t)->lstrit);
251: break;
252:
253: case TORF:
254: prf(lstptr(t)->lstlef);
255: prfstr(" || ");
256: prf(lstptr(t)->lstrit);
257: break;
258:
259: case TFOR:
260: {
261: register struct argnod *arg;
262: register struct fornod *f = (struct fornod *)t;
263:
264: prfstr("for ");
265: prfstr(f->fornam);
266:
267: if (f->forlst)
268: {
269: arg = f->forlst->comarg;
270: prfstr(" in");
271:
272: while(arg != ENDARGS)
273: {
274: prfc(SP);
275: prfqstr(arg->argval);
276: arg = arg->argnxt;
277: }
278: }
279:
280: prfstr("\ndo\n");
281: prf(f->fortre);
282: prfstr("\ndone");
283: }
284: break;
285:
286: case TWH:
287: case TUN:
288: if (type == TWH)
289: prfstr("while ");
290: else
291: prfstr("until ");
292: prf(whptr(t)->whtre);
293: prfstr("\ndo\n");
294: prf(whptr(t)->dotre);
295: prfstr("\ndone");
296: break;
297:
298: case TIF:
299: {
300: struct ifnod *f = (struct ifnod *)t;
301:
302: prfstr("if ");
303: prf(f->iftre);
304: prfstr("\nthen\n");
305: prf(f->thtre);
306:
307: if (f->eltre)
308: {
309: prfstr("\nelse\n");
310: prf(f->eltre);
311: }
312:
313: prfstr("\nfi");
314: break;
315: }
316:
317: case TSW:
318: {
319: register struct regnod *swl;
320:
321: prfstr("case ");
322: prfqstr(swptr(t)->swarg);
323: prfstr(" in\n");
324:
325: swl = swptr(t)->swlst;
326: while(swl)
327: {
328: struct argnod *arg = swl->regptr;
329:
330: if (arg)
331: {
332: prfqstr(arg->argval);
333: arg = arg->argnxt;
334: }
335:
336: while(arg)
337: {
338: prfc('|');
339: prfqstr(arg->argval);
340: arg = arg->argnxt;
341: }
342:
343: prfstr(") ");
344: prf(swl->regcom);
345: prfstr(";;\n");
346: swl = swl->regnxt;
347: }
348: prfstr("esac");
349: }
350: break;
351: }
352: }
353:
354: sigchk();
355: }
356:
357: prarg(argp)
358: register struct argnod *argp;
359: {
360: while (argp)
361: {
362: prfqstr(argp->argval);
363: prfc(SP);
364: argp=argp->argnxt;
365: }
366: }
367:
368: prio(iop)
369: register struct ionod *iop;
370: {
371: register int iof;
372: register char *ion;
373:
374: while (iop)
375: {
376: iof = iop->iofile;
377: ion = iop->ioname;
378:
379: if (*ion)
380: {
381: itos(iof & IOUFD);
382: prfstr(numbuf);
383:
384: if (iof & IODOC)
385: prfstr("<");
386: else if (iof & IOMOV)
387: {
388: if (iof & IOPUT)
389: prfstr(">&");
390: else
391: prfstr("<&");
392:
393: }
394: else if ((iof & IOPUT) == 0)
395: prfc('<');
396: else if (iof & IOAPP)
397: prfstr(">>");
398: else
399: prfc('>');
400:
401: prfstr(ion);
402: prfc(SP);
403: }
404: iop = iop->ionxt;
405: }
406: }
407: prfqstr(p)
408: register char *p;
409: {
410: int quote, equote;
411: int allquotes;
412: more:
413: quote = equote = allquotes = 0;
414: if(*p == '"'){
415: register char *t = p;
416: quote = equote = '"';
417: allquotes = 1;
418: while(*++t!='"')
419: if(!(*t"E)){
420: allquotes=0;
421: break;
422: }
423: if(allquotes)
424: quote='\'';
425: prfc(quote);
426: p++;
427: }
428: while(*p != equote){
429: if(*p=='"')
430: goto more;
431: if(!allquotes && (*p"E))
432: prfc('\\');
433: prfc(*p++&~QUOTE);
434: }
435: if(quote){
436: prfc(quote);
437: if(*++p != 0)
438: goto more;
439: }
440: }
441:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.