![[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] / researchv8dc / cmd / sh|
Return to func.c CVS log | Up to [Research Unix] / researchv8dc / 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: static char *strfp;
12:
13: #define prfc(c) (*strfp++ = (c))
14:
15: freefunc(val)
16: char *val;
17: {
18: freetree((struct trenod *)val);
19: }
20:
21:
22: freetree(t)
23: register struct trenod *t;
24: {
25: if (t)
26: {
27: register int type;
28:
29: if (t->tretyp & CNTMSK)
30: {
31: t->tretyp--;
32: return;
33: }
34:
35: type = t->tretyp & COMMSK;
36:
37: switch (type)
38: {
39: case TFND:
40: free(fndptr(t)->fndnam);
41: freetree(fndptr(t)->fndval);
42: break;
43:
44: case TCOM:
45: freeio(comptr(t)->comio);
46: free_arg(comptr(t)->comarg);
47: free_arg(comptr(t)->comset);
48: break;
49:
50: case TFORK:
51: freeio(forkptr(t)->forkio);
52: freetree(forkptr(t)->forktre);
53: break;
54:
55: case TPAR:
56: freetree(parptr(t)->partre);
57: break;
58:
59: case TFIL:
60: case TLST:
61: case TAND:
62: case TORF:
63: freetree(lstptr(t)->lstlef);
64: freetree(lstptr(t)->lstrit);
65: break;
66:
67: case TFOR:
68: {
69: struct fornod *f = (struct fornod *)t;
70:
71: free(f->fornam);
72: freetree(f->fortre);
73: if (f->forlst)
74: {
75: freeio(f->forlst->comio);
76: free_arg(f->forlst->comarg);
77: free_arg(f->forlst->comset);
78: free(f->forlst);
79: }
80: }
81: break;
82:
83: case TWH:
84: case TUN:
85: freetree(whptr(t)->whtre);
86: freetree(whptr(t)->dotre);
87: break;
88:
89: case TIF:
90: freetree(ifptr(t)->iftre);
91: freetree(ifptr(t)->thtre);
92: freetree(ifptr(t)->eltre);
93: break;
94:
95: case TSW:
96: free(swptr(t)->swarg);
97: freereg(swptr(t)->swlst);
98: break;
99: }
100: free(t);
101: }
102: }
103:
104: free_arg(argp)
105: register struct argnod *argp;
106: {
107: register struct argnod *sav;
108:
109: while (argp)
110: {
111: sav = argp->argnxt;
112: free(argp);
113: argp = sav;
114: }
115: }
116:
117:
118: freeio(iop)
119: register struct ionod *iop;
120: {
121: register struct ionod *sav;
122:
123: while (iop)
124: {
125: if ((iop->iofile & IODOC) && fiotemp != 0)
126: {
127:
128: #ifdef DEBUG
129: prs("unlinking ");
130: prs(iop->ioname);
131: newline();
132: #endif
133:
134: unlink(iop->ioname);
135:
136: if (fiotemp == iop)
137: fiotemp = iop->iolst;
138: else
139: {
140: struct ionod *fiop = fiotemp;
141:
142: while (fiop->iolst != iop)
143: fiop = fiop->iolst;
144:
145: fiop->iolst = iop->iolst;
146: }
147: }
148: free(iop->ioname);
149: free(iop->iolink);
150: sav = iop->ionxt;
151: free(iop);
152: iop = sav;
153: }
154: }
155:
156:
157: freereg(regp)
158: register struct regnod *regp;
159: {
160: register struct regnod *sav;
161:
162: while (regp)
163: {
164: free_arg(regp->regptr);
165: freetree(regp->regcom);
166: sav = regp->regnxt;
167: free(regp);
168: regp = sav;
169: }
170: }
171: /*
172: * Leaves string on top of stack
173: */
174: char *
175: strf(n)
176: register struct namnod *n;
177: {
178: strfp = locstak();
179: prfstr(n->namid);
180: prfstr("(){\n");
181: prf(n->namval.val);
182: prfstr("\n}");
183: return curstak();
184: }
185: prfstr(s)
186: char *s;
187: {
188: strfp = movstr(s, strfp);
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.